From e075dc2d13120c3ead10fcd450e2db6a52da18b0 Mon Sep 17 00:00:00 2001
From: Katherine Parry <kparry4@gmail.com>
Date: Tue, 13 Apr 2021 18:27:13 +0000
Subject: [PATCH] Various bugs fixed in FMA

---
 wally-pipelined/src/fpu/FMA/add.sv            |      2 +-
 wally-pipelined/src/fpu/FMA/align.sv          |     13 +-
 wally-pipelined/src/fpu/FMA/booth.sv          |     55 +
 wally-pipelined/src/fpu/FMA/compressors.sv    |     90 +
 wally-pipelined/src/fpu/FMA/expgen.sv         |     12 +-
 wally-pipelined/src/fpu/FMA/flag.sv           |     21 +-
 .../src/fpu/FMA/{fmac.sv => fma.sv}           |     59 +-
 wally-pipelined/src/fpu/FMA/lza.sv            |      2 +-
 wally-pipelined/src/fpu/FMA/multiply.sv       |    120 +-
 wally-pipelined/src/fpu/FMA/normalize.sv      |     46 +-
 wally-pipelined/src/fpu/FMA/round.sv          |     41 +-
 wally-pipelined/src/fpu/FMA/sign.sv           |     31 +-
 wally-pipelined/src/fpu/FMA/special.sv        |     62 +-
 wally-pipelined/src/fpu/FMA/tbgen/results.dat |     17 +-
 wally-pipelined/src/fpu/FMA/tbgen/tb          |    Bin 13160 -> 13160 bytes
 wally-pipelined/src/fpu/FMA/tbgen/tb.c        |     96 +-
 wally-pipelined/src/fpu/FMA/tbgen/tb.v        | 442912 +++++----------
 wally-pipelined/src/fpu/FMA/tbgen/tbhead.v    |     29 +-
 wally-pipelined/src/fpu/FMA/tbgen/test_gen.sh |      2 +-
 wally-pipelined/src/fpu/csa.sv                |      2 +-
 20 files changed, 136386 insertions(+), 307226 deletions(-)
 create mode 100644 wally-pipelined/src/fpu/FMA/booth.sv
 create mode 100644 wally-pipelined/src/fpu/FMA/compressors.sv
 rename wally-pipelined/src/fpu/FMA/{fmac.sv => fma.sv} (61%)

diff --git a/wally-pipelined/src/fpu/FMA/add.sv b/wally-pipelined/src/fpu/FMA/add.sv
index 88ba5dadc..ec2965349 100644
--- a/wally-pipelined/src/fpu/FMA/add.sv
+++ b/wally-pipelined/src/fpu/FMA/add.sv
@@ -48,7 +48,7 @@ module add(r, s, t, sum,
 
 	// Compound adder
 	// Consists of 3:2 CSA followed by long compound CPA
-	assign prodshifted = killprod ? 0 : {56'b0, r2, 2'b0} + {56'b0, s2, 2'b0};
+	assign prodshifted = killprod ? 0 : {56'b0, r2+s2, 2'b0};
 	assign sum0 = {1'b0,prodshifted} + t2 + 158'b0;
 	assign sum1 = {1'b0,prodshifted} + t2 + 158'b1; // +1 from invert of z above
 	
diff --git a/wally-pipelined/src/fpu/FMA/align.sv b/wally-pipelined/src/fpu/FMA/align.sv
index e71f71479..d696c784a 100644
--- a/wally-pipelined/src/fpu/FMA/align.sv
+++ b/wally-pipelined/src/fpu/FMA/align.sv
@@ -56,7 +56,7 @@ module align(zman, ae, aligncnt, xzero, yzero, zzero, zdenorm, proddenorm, t, bs
 	// addend on right shifts.  Handle special cases of shifting
 	// by too much.
 
-	always @(aligncnt or zman or zdenorm)
+	always @(aligncnt or xzero or yzero or zman or zdenorm or zzero)
 		begin
 
 		// Default to clearing sticky bits 
@@ -67,26 +67,23 @@ module align(zman, ae, aligncnt, xzero, yzero, zzero, zdenorm, proddenorm, t, bs
 		killprod = xzero | yzero;
 		// d = aligncnt
 		// p = 53
-		if ($signed(aligncnt) <= $signed(-103)) begin //d<=-2p+1
+		if ($signed(aligncnt) <= $signed(-105)) begin //d<=-2p+1
 			//product ancored case with saturated shift
 			sumshift = 163;	// 3p+4	
 			sumshiftzero = 0;
-			shift = {~zdenorm,zman,163'b0} >> sumshift;
+			shift = {1'b1,zman,163'b0} >> sumshift;
 			t = zzero ? 0 : {shift[215:52]};
 			bs = |(shift[51:0]);
 			//zexpsel = 0;
-		end else if($signed(aligncnt) <= $signed(1))  begin // -2p+1<d<=2
-			// set d<=2 to d<=0
+		end else if($signed(aligncnt) <= $signed(2))  begin // -2p+1<d<=2
 			// product ancored or cancellation
-			// warning: set to 55 rather then 56. was there a typo in the book?
-			sumshift = 57-aligncnt; // p + 3 - d  
+			sumshift = 57-aligncnt; // p + 2 - d  
 			sumshiftzero = 0;
 			shift = {~zdenorm,zman,163'b0} >> sumshift;
 			t = zzero ? 0 : {shift[215:52]};
 			bs = |(shift[51:0]);
 			//zexpsel = 0;
 		end else if ($signed(aligncnt)<=$signed(55))  begin // 2 < d <= p+2
-			// another typo in book? above was 55 changed to 52
 			// addend ancored case
 			// used to be 56 \/ somthing doesn't seem right too many typos
 			sumshift = 57-aligncnt;
diff --git a/wally-pipelined/src/fpu/FMA/booth.sv b/wally-pipelined/src/fpu/FMA/booth.sv
new file mode 100644
index 000000000..73a5f44c1
--- /dev/null
+++ b/wally-pipelined/src/fpu/FMA/booth.sv
@@ -0,0 +1,55 @@
+module booth(xExt, choose, add1, e, pp); 
+/////////////////////////////////////////////////////////////////////////////
+    
+	input 		[53:0]		xExt;				// multiplicand	xExt
+	input		[2:0]		choose;				// bits needed to choose which encoding
+	output		[1:0]       	add1;				// do you add 1	
+    output                  e;
+	output		[54:0]		pp;				//	the resultant encoding
+    
+    logic [54:0] pp, temp;
+    logic e;
+    logic [1:0] add1;
+    logic [53:0] negx;
+    //logic temp;
+
+    assign negx = ~xExt;
+
+    always @(choose, xExt, negx)
+    case (choose)
+        3'b000 : pp = 55'b0;   //  0
+        3'b001 : pp = {1'b0, xExt};  //  1
+        3'b010 : pp = {1'b0, xExt};  //  1
+        3'b011 : pp = {xExt, 1'b0};  //  2
+        3'b100 : pp = {negx, 1'b0};  // -2
+        3'b101 : pp = {1'b1, negx};  // -1
+        3'b110 : pp = {1'b1, negx};  // -1
+        3'b111 : pp = 55'hfffffffffffffff;  //  -0
+    endcase
+
+    always @(choose, xExt, negx)
+    case (choose)
+        3'b000 : e = 0;   //  0
+        3'b001 : e = 0;  //  1
+        3'b010 : e = 0;  //  1
+        3'b011 : e = 0;  //  2
+        3'b100 : e = 1;  // -2
+        3'b101 : e = 1;  // -1
+        3'b110 : e = 1;  // -1
+        3'b111 : e = 1;  //  -0
+    endcase
+    // assign add1 = (choose[2] == 1'b1) ? ((choose[1:0] == 2'b11) ? 1'b0 : 1'b1) : 1'b0;
+    // assign add1 = choose[2];
+    always @(choose)
+    case (choose)
+        3'b000 : add1 = 2'b0;   //  0
+        3'b001 : add1 = 2'b0;  //  1
+        3'b010 : add1 = 2'b0;  //  1
+        3'b011 : add1 = 2'b0;  //  2
+        3'b100 : add1 = 2'b10;  // -2
+        3'b101 : add1 = 2'b1;  // -1
+        3'b110 : add1 = 2'b1;  // -1
+        3'b111 : add1 = 2'b1;  //  -0
+    endcase
+
+endmodule
diff --git a/wally-pipelined/src/fpu/FMA/compressors.sv b/wally-pipelined/src/fpu/FMA/compressors.sv
new file mode 100644
index 000000000..9dd3fc116
--- /dev/null
+++ b/wally-pipelined/src/fpu/FMA/compressors.sv
@@ -0,0 +1,90 @@
+module add3comp2(a, b, c, carry, sum); 
+/////////////////////////////////////////////////////////////////////////////
+//look into diffrent implementations of the compressors?
+    
+    parameter BITS = 4;
+	input 		[BITS-1:0]		a;
+	input		[BITS-1:0]		b;
+	input		[BITS-1:0]    	c;
+    output      [BITS-1:0]      carry;
+	output		[BITS-1:0]		sum;
+    genvar i;
+
+    generate
+        for(i= 0; i<BITS; i=i+1) begin
+            sng3comp2 add0(a[i], b[i], c[i], carry[i], sum[i]);
+        end
+    endgenerate
+
+endmodule
+
+module add4comp2(a, b, c, d, carry, sum); 
+/////////////////////////////////////////////////////////////////////////////
+    
+    parameter BITS = 4;
+	input 		[BITS-1:0]		a;
+	input		[BITS-1:0]		b;
+	input		[BITS-1:0]    	c;
+	input		[BITS-1:0]    	d;
+    output      [BITS:0]      carry;
+	output		[BITS-1:0]		sum;
+
+    logic       [BITS-1:0]      cout;
+    logic                       carryTmp;
+    genvar i;
+
+
+    sng4comp2 add0(a[0], b[0], c[0], d[0], 1'b0, cout[0], carry[0], sum[0]);
+
+    generate
+        for(i= 1; i<BITS-1; i=i+1) begin
+            sng4comp2 add1(a[i], b[i], c[i], d[i], cout[i-1], cout[i], carry[i], sum[i]);
+        end
+    endgenerate
+
+
+    sng4comp2 add2(a[BITS-1], b[BITS-1], c[BITS-1], d[BITS-1], cout[BITS-2], cout[BITS-1], carryTmp, sum[BITS-1]);
+
+    assign carry[BITS-1] = carryTmp & cout[BITS-1];
+    assign carry[BITS] = carryTmp ^ cout[BITS-1];
+
+endmodule
+
+module sng3comp2(a, b, c, carry, sum); 
+/////////////////////////////////////////////////////////////////////////////
+//look into diffrent implementations of the compressors?
+    
+	input 				a;
+	input				b;
+	input		       	c;
+    output              carry;
+	output				sum;
+    
+    logic               axorb;
+
+    assign axorb = a ^ b;
+    assign sum = axorb ^ c;
+
+    assign carry = axorb ? c : a;
+
+endmodule
+
+module sng4comp2(a, b, c, d, cin, cout, carry, sum); 
+/////////////////////////////////////////////////////////////////////////////
+//look into pass gate 4:2 counters?
+    
+	input 				a;
+	input				b;
+	input		       	c;
+    input               d;
+    input               cin;
+    output              cout;
+    output              carry;
+	output				sum;
+    
+    logic               TmpSum;
+
+    sng3comp2 add1(.carry(cout), .sum(TmpSum),.*);
+    sng3comp2 add2(.a(TmpSum), .b(d), .c(cin), .*);
+
+endmodule
\ No newline at end of file
diff --git a/wally-pipelined/src/fpu/FMA/expgen.sv b/wally-pipelined/src/fpu/FMA/expgen.sv
index 15f5f8f77..ef2487770 100644
--- a/wally-pipelined/src/fpu/FMA/expgen.sv
+++ b/wally-pipelined/src/fpu/FMA/expgen.sv
@@ -17,7 +17,7 @@
 /////////////////////////////////////////////////////////////////////////////
 module expgen(xexp, yexp, zexp,
 			   killprod,  sumzero, resultdenorm, normcnt, infinity, 
-			   invalid, overflow, underflow, inf, xzero, yzero,expplus1,
+			   FmaFlagsM, inf, xzero, yzero,expplus1,
 			   nan, de0, xnan, ynan, znan, xdenorm, ydenorm, zdenorm, proddenorm, specialsel, zexpsel,
 			   aligncnt, wexp,
 			   prodof, sumof, sumuf, denorm0, ae);
@@ -31,9 +31,7 @@ module expgen(xexp, yexp, zexp,
 	input     			resultdenorm;  // postnormalize rounded result
 	input     	[8:0]  		normcnt;     	// normalization shift count 
 	input     			infinity;    	// generate infinity on overflow 
-	input     			invalid;     	// Result invalid
-	input     			overflow;    	// Result overflowed
-	input     			underflow;   	// Result underflowed 
+	input     	[4:0]	FmaFlagsM;     	// Result invalid
 	input     			inf;			// Some input is infinity
 	input     			nan;			// Some input is NaN
 	input     	[12:0]		de0;			// X is NaN NaN
@@ -121,10 +119,10 @@ module expgen(xexp, yexp, zexp,
 	// produces either infinity or the largest finite number, depending on the
 	// rounding mode.  NaNs are propagated or generated.
 
-	assign specialres = invalid | nan ? nanres : // KEP added nan
-					overflow ? infinityres : 
+	assign specialres = FmaFlagsM[4] | nan ? nanres : // invalid
+					FmaFlagsM[2] ? infinityres : 	//overflow
 					inf ? 11'b11111111111 :
-					underflow ? 11'b0 : 11'bx;
+					FmaFlagsM[1] ? 11'b0 : 11'bx; //underflow
 
 	assign infinityres = infinity ? 11'b11111111111 : 11'b11111111110;
 
diff --git a/wally-pipelined/src/fpu/FMA/flag.sv b/wally-pipelined/src/fpu/FMA/flag.sv
index 14ae0b5f7..d32654abc 100644
--- a/wally-pipelined/src/fpu/FMA/flag.sv
+++ b/wally-pipelined/src/fpu/FMA/flag.sv
@@ -10,12 +10,13 @@
 /////////////////////////////////////////////////////////////////////////////
 module flag(xnan, ynan, znan, xinf, yinf, zinf, prodof, sumof, sumuf,
 			 psign,  zsign, xzero, yzero, zzero, vbits, killprod,
-			 inf, nan, invalid, overflow, underflow, inexact);
+			 inf, nan, FmaFlagsM,sticky);
 /////////////////////////////////////////////////////////////////////////////
 
 	input                  		xnan;        	// X is NaN 
 	input                  		ynan;        	// Y is NaN 
 	input                 		znan;       	// Z is NaN 
+	input                  		sticky;        	// X is Inf
 	input                  		xinf;        	// X is Inf
 	input                 		yinf;       	// Y is Inf 
 	input                  		zinf;        	// Z is Inf
@@ -31,10 +32,7 @@ module flag(xnan, ynan, znan, xinf, yinf, zinf, prodof, sumof, sumuf,
 	input     	[1:0]  		vbits;		// R and S bits of result
 	output				inf;		// Some	source is Inf
 	output				nan;		// Some	source is NaN
-	output				invalid;	// Result is invalid	
-	output				overflow;	// Result overflowed	
-	output				underflow;	// Result underflowed	
-	output				inexact;	// Result is not an exact number
+	output		[4:0]	FmaFlagsM;
  
 	//   Internal nodes
 
@@ -55,33 +53,36 @@ module flag(xnan, ynan, znan, xinf, yinf, zinf, prodof, sumof, sumuf,
 
 	assign prodinf = prodof && ~xnan && ~ynan;
 	//KEP added if the product is infinity then sum is infinity
-	assign suminf = prodinf | sumof && ~xnan && ~ynan && ~znan;
+	assign suminf = sumof && ~xnan && ~ynan && ~znan;
 
 	// Set invalid flag for following cases:
 	//   1) Inf - Inf
 	//   2) 0 * Inf
 	//   3) Output = NaN (this is not part of the IEEE spec,  only 486 proj)
 
-	assign invalid = (xinf || yinf || prodinf) && zinf && (psign ^ zsign) ||
+	assign FmaFlagsM[4] = (xinf || yinf || prodinf) && zinf && (psign ^ zsign) ||
 					   xzero && yinf || yzero && xinf;// KEP remove case 3) above
 
+	assign FmaFlagsM[3] = 0; // divide by zero flag
+
+
 	// Set the overflow flag for the following cases:
 	//   1) Rounded multiply result would be out of bounds
 	//   2) Rounded add result would be out of bounds
 
-	assign overflow = suminf && ~inf;
+	assign FmaFlagsM[2] = suminf && ~inf;
 
 	// Set the underflow  flag for the following cases:
 	//   1) Any input is denormalized
 	//   2)  Output would be denormalized or smaller
 
-	assign underflow = (sumuf && ~inf && ~prodinf && ~nan) || (killprod & zzero & ~(yzero | xzero));
+	assign FmaFlagsM[1] = (sumuf && ~inf && ~prodinf && ~nan) || (killprod & zzero & ~(yzero | xzero));
 
 	// Set the inexact flag for the following cases:
 	//   1) Multiplication inexact
 	//   2) Addition  inexact
 	// One of these cases occurred if the R or S bit is set
 
-	assign inexact = (vbits[0] || vbits[1]  || suminf) && ~(inf || nan);
+	assign FmaFlagsM[0] = (vbits[0] || vbits[1] ||sticky  || suminf) && ~(inf || nan);
 
 endmodule
diff --git a/wally-pipelined/src/fpu/FMA/fmac.sv b/wally-pipelined/src/fpu/FMA/fma.sv
similarity index 61%
rename from wally-pipelined/src/fpu/FMA/fmac.sv
rename to wally-pipelined/src/fpu/FMA/fma.sv
index 5245c74c3..21fd801e6 100644
--- a/wally-pipelined/src/fpu/FMA/fmac.sv
+++ b/wally-pipelined/src/fpu/FMA/fma.sv
@@ -15,13 +15,13 @@
 //    normalize Normalization shifter
 //    round     Rounding of result
 //    exception Handles exceptional cases
-//    bypass    Handles bypass of result to X or Z inputs
+//    bypass    Handles bypass of result to ReadData1E or ReadData3E inputs
 //    sign      One bit sign handling block 
 //    special   Catch special cases (inputs = 0  / infinity /  etc.) 
 //
-//   The FMAC computes W=X*Y+Z, rounded with the mode specified by
+//   The FMAC computes FmaResultM=ReadData1E*ReadData2E+ReadData3E, rounded with the mode specified by
 //   RN, RZ, RM, or RP.  The result is optionally bypassed back to
-//   the X or Z inputs for use on the next cycle.  In addition,  four signals
+//   the ReadData1E or ReadData3E inputs for use on the next cycle.  In addition,  four signals
 //   are produced: trap, overflow, underflow, and inexact.  Trap indicates
 //   an infinity, NaN, or denormalized number to be handled in software;
 //   the other three signals are IEEE flags.
@@ -29,29 +29,17 @@
 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
-module fmac(x, y, z, rn, rz, rp, rm,
-			earlyres, earlyressel, bypsel, bypplus1, byppostnorm, 
-			w, wbypass, invalid, overflow, underflow, inexact);
+module fma(ReadData1E, ReadData2E, ReadData3E, FrmE,
+			FmaResultM, FmaFlagsM, aligncnt);
 /////////////////////////////////////////////////////////////////////////////
  
-	input 		[63:0]		x;			// input X from reg file
-	input		[63:0]		y;				// input Y  
-	input 		[63:0]		z;          	// input Z from reg file 
-	input 			 		rn;          	// Round to Nearest
-	input 					rz;           	// Round toward zero
-	input 					rm;          	// Round toward minus infinity
-	input 					rp;          	// Round toward plus infinity
-	input 		[63:0]		earlyres;    	// Early result from other FP logic
-	input 					earlyressel;	// Select early result, not W 
-	input 		[1:0]		bypsel;     	// Select W bypass to X, or z 
-	input 					bypplus1;    	// Add one in bypass
-	input 					byppostnorm;	// postnormalize in bypass
-	output 		[63:0]		w;           	// output W=X*Y+Z
-	output 		[63:0]		wbypass;     	// prerounded output W=X*Y+Z for bypass
-	output 					invalid;    	// Result is invalid 
-	output					overflow;		// Result overflowed 
-	output					underflow;   	// Result underflowed
-	output 					inexact;     	// Result is not an exact number 
+	input 		[63:0]		ReadData1E;		// input 1
+	input		[63:0]		ReadData2E;     // input 2 
+	input 		[63:0]		ReadData3E;     // input 3
+	input 		[2:0]	 	FrmE;          	// Rounding mode
+	output 		[63:0]		FmaResultM;     // output FmaResultM=ReadData1E*ReadData2E+ReadData3E
+	output 		[4:0]		FmaFlagsM;    	// status flags
+	output 		[12:0]		aligncnt;    	// status flags
 
 // Internal nodes
  
@@ -60,12 +48,12 @@ module fmac(x, y, z, rn, rz, rp, rm,
 	logic 		[163:0]		t;				// output of alignment shifter
 	logic 		[163:0]		sum;			// output of carry prop adder
 	logic 		[53:0]		v; 				// normalized sum, R, S bits
-	logic 		[12:0]		aligncnt; 		// shift count for alignment
+//	logic 		[12:0]		aligncnt; 		// shift count for alignment
 	logic 		[8:0]		normcnt; 		// shift count for normalizer
 	logic 		[12:0]		ae; 		// multiplier expoent
 	logic 					bs;				// sticky bit of addend
 	logic 					ps;				// sticky bit of product
-	logic 					killprod; 		// Z >> product
+	logic 					killprod; 		// ReadData3E >> product
 	logic 					negsum; 		// negate sum
 	logic 					invz; 			// invert addend
 	logic 					selsum1; 		// select +1 mode of sum
@@ -73,7 +61,7 @@ module fmac(x, y, z, rn, rz, rp, rm,
 	logic 					negsum1; 		// sum +1 < 0
 	logic 					sumzero; 		// sum = 0
 	logic 					infinity; 		// generate infinity on overflow
-	logic 					prodof; 		// X*Y out of range
+	logic 					prodof; 		// ReadData1E*ReadData2E out of range
 	logic 					sumof;			// result out of range
 	logic					xzero;
 	logic					yzero;
@@ -101,6 +89,9 @@ module fmac(x, y, z, rn, rz, rp, rm,
 	logic			[8:0]		sumshift;
 	logic					sumshiftzero;
 	logic			[12:0]		de0;
+	logic					isAdd;
+
+	assign isAdd = 1;
 
 
 
@@ -117,16 +108,16 @@ module fmac(x, y, z, rn, rz, rp, rm,
 
 //   Instantiate fraction datapath
 
-	multiply		multiply(.xman(x[51:0]), .yman(y[51:0]), .*);
-	align			align(.zman(z[51:0]),.*);
+	multiply		multiply(.xman(ReadData1E[51:0]), .yman(ReadData2E[51:0]), .*);
+	align			align(.zman(ReadData3E[51:0]),.*);
 	add				add(.*);
 	lza				lza(.*);
-	normalize		normalize(.zexp(z[62:52]),.*); 
-	round			round(.xman(x[51:0]), .yman(y[51:0]),.zman(z[51:0]), .wman(w[51:0]),.wsign(w[63]),.*);
+	normalize		normalize(.xexp(ReadData1E[62:52]),.yexp(ReadData2E[62:52]),.zexp(ReadData3E[62:52]),.*); 
+	round			round(.xman(ReadData1E[51:0]), .yman(ReadData2E[51:0]),.zman(ReadData3E[51:0]), .wman(FmaResultM[51:0]),.wsign(FmaResultM[63]),.*);
 
 // Instantiate exponent datapath
 
-	expgen			expgen(.xexp(x[62:52]),.yexp(y[62:52]),.zexp(z[62:52]),.wexp(w[62:52]),.*);
+	expgen			expgen(.xexp(ReadData1E[62:52]),.yexp(ReadData2E[62:52]),.zexp(ReadData3E[62:52]),.wexp(FmaResultM[62:52]),.*);
 // Instantiate special case detection across datapath & exponent path 
 
 	special			special(.*);
@@ -134,8 +125,8 @@ module fmac(x, y, z, rn, rz, rp, rm,
 
 // Instantiate control logic
  
-sign				sign(.xsign(x[63]),.ysign(y[63]),.zsign(z[63]),.wsign(w[63]),.*); 
-flag				flag(.zsign(z[63]),.vbits(v[1:0]),.*); 
+sign				sign(.xsign(ReadData1E[63]),.ysign(ReadData2E[63]),.zsign(ReadData3E[63]),.wsign(FmaResultM[63]),.*); 
+flag				flag(.zsign(ReadData3E[63]),.vbits(v[1:0]),.*); 
 
 endmodule
 
diff --git a/wally-pipelined/src/fpu/FMA/lza.sv b/wally-pipelined/src/fpu/FMA/lza.sv
index 8b53d0fe1..5574dc323 100644
--- a/wally-pipelined/src/fpu/FMA/lza.sv
+++ b/wally-pipelined/src/fpu/FMA/lza.sv
@@ -30,7 +30,7 @@ module lza(sum, normcnt, sumzero);
 	always @ ( sum)
 		begin
 			i =   0;
-			while (~sum[108-i] && i < 108) i = i+1;  // search for leading one 
+			while (~sum[163-i] && i <= 163) i = i+1;  // search for leading one 
 			normcnt = i;    // compute shift count
 	end
 
diff --git a/wally-pipelined/src/fpu/FMA/multiply.sv b/wally-pipelined/src/fpu/FMA/multiply.sv
index edcd67c1c..c5fb83568 100644
--- a/wally-pipelined/src/fpu/FMA/multiply.sv
+++ b/wally-pipelined/src/fpu/FMA/multiply.sv
@@ -10,8 +10,124 @@ module multiply(xman, yman, xdenorm, ydenorm, xzero, yzero, r, s);
 	input     			yzero;		// Z is denorm
 	output		[105:0]		r;				//	partial product 1	
 	output		[105:0]		s;				//	partial product 2	
+    
+     wire        [54:0]      yExt; //y with appended 0 and assumed 1
+     wire        [53:0]      xExt; //y with assumed 1
+     wire [26:0][1:0] add1;
+     wire [26:0][54:0] pp; 
+     wire [26:0] e;
+     logic [17:0][105:0] lv1add;
+     logic [11:0][105:0] lv2add;
+     logic [7:0][105:0] lv3add;
+     logic [3:0][105:0] lv4add;
+     logic [21:0][106:0] carryTmp;
+     wire [26:0][105:0] acc; 
+     // wire [105:0] acc
+    genvar i;	
 
-	assign r = 106'b0;
-	assign s = {53'b0,~(xdenorm|xzero),xman}  *  {53'b0,~(ydenorm|yzero),yman};
+	assign xExt = {2'b0,~(xdenorm|xzero),xman};
+	assign yExt = {2'b0,~(ydenorm|yzero),yman, 1'b0};
+    
+     generate
+        for(i=0; i<27; i=i+1) begin
+            booth booth(.xExt(xExt), .choose(yExt[(i*2)+2:i*2]), .add1(add1[i]), .e(e[i]), .pp(pp[i]));
+        end
+     endgenerate
 
+    assign acc[0] = {49'b0,~e[0],e[0],e[0],pp[0]}; 
+    assign acc[1] = {50'b01,~e[1],pp[1],add1[0]}; 
+    assign acc[2] = {48'b01,~e[2],pp[2],add1[1], 2'b0};
+    assign acc[3] = {46'b01,~e[3],pp[3],add1[2], 4'b0};
+    assign acc[4] = {44'b01,~e[4],pp[4],add1[3], 6'b0};
+    assign acc[5] = {42'b01,~e[5],pp[5],add1[4], 8'b0};
+    assign acc[6] = {40'b01,~e[6],pp[6],add1[5], 10'b0};
+    assign acc[7] = {38'b01,~e[7],pp[7],add1[6], 12'b0};
+    assign acc[8] = {36'b01,~e[8],pp[8],add1[7], 14'b0};
+    assign acc[9] = {34'b01,~e[9],pp[9],add1[8], 16'b0};
+    assign acc[10] = {32'b01,~e[10],pp[10],add1[9], 18'b0};
+    assign acc[11] = {30'b01,~e[11],pp[11],add1[10], 20'b0};
+    assign acc[12] = {28'b01,~e[12],pp[12],add1[11], 22'b0};
+    assign acc[13] = {26'b01,~e[13],pp[13],add1[12], 24'b0};
+    assign acc[14] = {24'b01,~e[14],pp[14],add1[13], 26'b0};
+    assign acc[15] = {22'b01,~e[15],pp[15],add1[14], 28'b0};
+    assign acc[16] = {20'b01,~e[16],pp[16],add1[15], 30'b0};
+    assign acc[17] = {18'b01,~e[17],pp[17],add1[16], 32'b0};
+    assign acc[18] = {16'b01,~e[18],pp[18],add1[17], 34'b0};
+    assign acc[19] = {14'b01,~e[19],pp[19],add1[18], 36'b0};
+    assign acc[20] = {12'b01,~e[20],pp[20],add1[19], 38'b0};
+    assign acc[21] = {10'b01,~e[21],pp[21],add1[20], 40'b0};
+    assign acc[22] = {8'b01,~e[22],pp[22],add1[21], 42'b0};
+    assign acc[23] = {6'b01,~e[23],pp[23],add1[22], 44'b0};
+    assign acc[24] = {4'b01,~e[24],pp[24],add1[23], 46'b0};
+    assign acc[25] = {~e[25],pp[25],add1[24], 48'b0};
+    assign acc[26] = {pp[26],add1[25], 50'b0};
+
+    //*** resize adders
+     generate
+        for(i=0; i<9; i=i+1) begin
+            add3comp2 #(.BITS(106)) add1(.a(acc[i*3]), .b(acc[i*3+1]), .c(acc[i*3+2]), 
+                                           .carry(carryTmp[i][105:0]), .sum(lv1add[i*2+1]));
+            assign lv1add[i*2] = {carryTmp[i][104:0], 1'b0};
+        end
+     endgenerate
+
+     generate
+        for(i=0; i<6; i=i+1) begin
+            add3comp2 #(.BITS(106)) add2(.a(lv1add[i*3]), .b(lv1add[i*3+1]), .c(lv1add[i*3+2]), 
+                                           .carry(carryTmp[i+9][105:0]), .sum(lv2add[i*2+1]));
+            assign lv2add[i*2] = {carryTmp[i+9][104:0], 1'b0};
+        end
+     endgenerate
+
+    generate
+        for(i=0; i<4; i=i+1) begin
+            add3comp2 #(.BITS(106)) add3(.a(lv2add[i*3]), .b(lv2add[i*3+1]), .c(lv2add[i*3+2]), 
+                                            .carry(carryTmp[i+15][105:0]), .sum(lv3add[i*2+1]));
+            assign lv3add[i*2] = {carryTmp[i+15][104:0], 1'b0};
+        end
+    endgenerate
+
+
+    generate
+        for(i=0; i<2; i=i+1) begin
+            add4comp2 #(.BITS(106)) add4(.a(lv3add[i*4]), .b(lv3add[i*4+1]), .c(lv3add[i*4+2]), .d(lv3add[i*4+3]),
+                                            .carry(carryTmp[i+19]), .sum(lv4add[i*2+1]));
+            assign lv4add[i*2] = {carryTmp[i+19][104:0], 1'b0};
+        end
+    endgenerate
+
+    add4comp2 #(.BITS(106)) add5(.a(lv4add[0]), .b(lv4add[1]), .c(lv4add[2]), .d(lv4add[3]) ,
+                                    .carry(carryTmp[21]), .sum(s));
+    assign r = {carryTmp[21][104:0], 1'b0};
+		// assign r = 0;
+		// assign s = acc[0] +
+		// 		   acc[1] +
+		// 		   acc[2] +
+		// 		   acc[3] +
+		// 		   acc[4] +
+		// 		   acc[5] +
+		// 		   acc[6] +
+		// 		   acc[7] +
+		// 		   acc[8] +
+		// 		   acc[9] +
+		// 		   acc[10] +
+		// 		   acc[11] +
+		// 		   acc[12] +
+		// 		   acc[13] +
+		// 		   acc[14] +
+		// 		   acc[15] +
+		// 		   acc[16] +
+		// 		   acc[17] +
+		// 		   acc[18] +
+		// 		   acc[19] +
+		// 		   acc[20] +
+		// 		   acc[21] +
+		// 		   acc[22] +
+		// 		   acc[23] +
+		// 		   acc[24] +
+		// 		   acc[25] +
+		// 		   acc[26];
+
+			// assign s = {53'b0,~(xdenorm|xzero),xman}  *  {53'b0,~(ydenorm|yzero),yman};
+			// assign r = 0;
 endmodule
diff --git a/wally-pipelined/src/fpu/FMA/normalize.sv b/wally-pipelined/src/fpu/FMA/normalize.sv
index 4ba01d959..5e19149cd 100644
--- a/wally-pipelined/src/fpu/FMA/normalize.sv
+++ b/wally-pipelined/src/fpu/FMA/normalize.sv
@@ -14,9 +14,11 @@
 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
-module normalize(sum, zexp, invz, normcnt, ae, aligncnt, sumshift, sumshiftzero, sumzero, xzero, yzero, bs, ps, denorm0, xdenorm, ydenorm, zdenorm, sticky, de0, resultdenorm, v); 
+module normalize(sum, xexp, yexp, zexp, invz, normcnt, ae, aligncnt, sumshift, sumshiftzero, sumzero, xzero, zzero, yzero, bs, ps, denorm0, xdenorm, ydenorm, zdenorm, sticky, de0, resultdenorm, v); 
 /////////////////////////////////////////////////////////////////////////////
 	input     	[163:0]  	sum;            // sum
+	input     	[62:52]  	xexp;            // sum
+	input     	[62:52]  	yexp;            // sum
 	input     	[62:52]  	zexp;            // sum
 	input		[8:0] 		normcnt;     	// normalization shift count
 	input		[12:0] 		ae;     	// normalization shift count
@@ -33,6 +35,7 @@ module normalize(sum, zexp, invz, normcnt, ae, aligncnt, sumshift, sumshiftzero,
 	input                  		zdenorm;        // Input Z is denormalized
 	input				xzero;
 	input				yzero;
+	input				zzero;
 	output				sticky;		//sticky bit
 	output		[12:0]		de0;
 	output                  	resultdenorm;        // Input Z is denormalized
@@ -47,6 +50,7 @@ module normalize(sum, zexp, invz, normcnt, ae, aligncnt, sumshift, sumshiftzero,
 	logic		[9:0]		sumshifttmp;
 	logic       	[163:0]  	sumshiftedtmp;     // shifted sum
 	logic 				sticky;
+	logic				isShiftLeft1;
 logic tmp,tmp1,tmp2,tmp3,tmp4, tmp5;
 
 	// When the sum is zero,  normalization does not apply and only the
@@ -60,21 +64,23 @@ logic tmp,tmp1,tmp2,tmp3,tmp4, tmp5;
 	// The sticky bit calculation is actually built into the shifter and
 	// does not require a true subtraction shown in the model.
  
+	assign isShiftLeft1 = (aligncnt == 1 ||aligncnt == 0 || $signed(aligncnt) == $signed(-1))&& zexp == 11'h2;//((xexp == 11'h3ff && yexp == 11'h1) || (yexp == 11'h3ff && xexp == 11'h1)) && zexp == 11'h2;
 	assign tmp = ($signed(ae-normcnt+2) >= $signed(-1022));
-	always @(sum or sumshift or ae or aligncnt or normcnt or bs or zexp or zdenorm)
+	always @(sum or sumshift or ae or aligncnt or normcnt or bs or isShiftLeft1 or zexp or zdenorm)
 		begin
 		// d = aligncnt
 		// l = normcnt
 		// p = 53
 		// ea + eb = ae
 			// set d<=2 to d<=0
-			if ($signed(aligncnt)<=$signed(1))  begin //d<=2 
+			if ($signed(aligncnt)<=$signed(2))  begin //d<=2 
 				// product anchored or cancellation
 				if ($signed(ae-normcnt+2) >= $signed(-1022)) begin //ea+eb-l+2 >= emin
 					//normal result
-					de0 = xzero|yzero ? zexp : ae-normcnt+2+xdenorm+ydenorm;
-					resultdenorm = |sum & ~|de0;
-					sumshifted = resultdenorm ? sum << sumshift : sum << (55+normcnt); // p+2+l
+					de0 = xzero|yzero ? zexp : ae-normcnt+xdenorm+ydenorm+57;
+					resultdenorm = |sum & ~|de0 | de0[12];
+					// if z is zero then there was a 56 bit shift of the product
+					sumshifted = resultdenorm ? sum << sumshift-zzero+isShiftLeft1 : sum << normcnt; // p+2+l
 					v = sumshifted[162:109];
 					sticky = (|sumshifted[108:0]) | bs;
 					//de0 = ae-normcnt+2-1023;
@@ -90,8 +96,8 @@ logic tmp,tmp1,tmp2,tmp3,tmp4, tmp5;
 				sumshifttmp = {1'b0,sumshift} - 2;
 				sumshifted = sumshifttmp[9] ? sum : sum << sumshifttmp;
 				tmp1 = (sumshifted[163] & ~sumshifttmp[9]);
-				tmp2 = (sumshifttmp[9] || sumshifted[162]);
-				tmp3 = sumshifted[161];
+				tmp2 = ((sumshifttmp[9] & sumshift[0]) || sumshifted[162]);
+				tmp3 = (sumshifted[161] || (sumshifttmp[9] & sumshift[1]));
 				tmp4 = sumshifted[160];
 				tmp5 = sumshifted[159];
 				// for some reason use exp = zexp + {0,1,2}
@@ -112,25 +118,31 @@ logic tmp,tmp1,tmp2,tmp3,tmp4, tmp5;
 					v = sumshifted[160:107];
 					sticky = (|sumshifted[106:0]) | bs;
 					//de0 = zexp-1;
-					de0 = zexp;
-				end else if(sumshifted[160]) begin
-					v = sumshifted[159:106];
+					de0 = zexp+zdenorm;
+				end else if(sumshifted[160]& ~zdenorm) begin
+					de0 = zexp-1;
+					v = ~|de0&~sumzero ? sumshifted[160:107] : sumshifted[159:106];
 					sticky = (|sumshifted[105:0]) | bs;
 					//de0 = zexp-1;
-					de0 = zexp-1;
-				end else if(sumshifted[159]) begin
-					v = sumshifted[158:105];
+				end else if(sumshifted[159]& ~zdenorm) begin
+					//v = sumshifted[158:105];
+					de0 = zexp-2;
+					v = (~|de0 | de0[12])&~sumzero ? sumshifted[161:108] : sumshifted[158:105];
 					sticky = (|sumshifted[104:0]) | bs;
 					//de0 = zexp-1;
-					de0 = zexp-2;
-				end else begin					
+				end else if(zdenorm) begin					
 					v = sumshifted[160:107];
 					sticky = (|sumshifted[106:0]) | bs;
 					//de0 = zexp-1;
 					de0 = zexp;
+				end else begin
+					de0 = 0;
+					sumshifted = sum << sumshift-1; // p+2+l
+					v = sumshifted[162:109];
+					sticky = (|sumshifted[108:0]) | bs;
 				end
 
-				resultdenorm = ~(|de0);
+				resultdenorm = (~|de0 | de0[12]);
 		end 
 	end
 
diff --git a/wally-pipelined/src/fpu/FMA/round.sv b/wally-pipelined/src/fpu/FMA/round.sv
index 76b03dbe6..908e3f24c 100644
--- a/wally-pipelined/src/fpu/FMA/round.sv
+++ b/wally-pipelined/src/fpu/FMA/round.sv
@@ -13,22 +13,17 @@
 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
-module round(v, sticky, rz, rn, rp, rm, wsign,
-			  invalid, overflow, underflow, inf, nan, xnan, ynan, znan, 
+module round(v, sticky, FrmE, wsign,
+			  FmaFlagsM, inf, nan, xnan, ynan, znan, 
 			  xman, yman, zman,
 			  wman, infinity, specialsel,expplus1);
 /////////////////////////////////////////////////////////////////////////////
 
 	input		[53:0]		v;		// normalized sum, R, S bits
 	input				sticky;		//sticky bit
-	input				rz;		// Round toward zero
-	input				rn;		// Round toward	nearest
-	input				rp;		// Round toward	plus infinity
-	input				rm;		// Round toward	minus infinity
+	input		[2:0]	FrmE;
 	input				wsign;		// Sign of result
-	input 				invalid;	// Trap on infinity, NaN, denorm
-	input				overflow;	// Result overflowed
-	input				underflow;	// Result underflowed
+	input 		[4:0]	FmaFlagsM;
 	input				inf;		// Some input is infinity
 	input				nan;		// Some input is NaN
 	input				xnan;		// X is NaN
@@ -45,7 +40,7 @@ module round(v, sticky, rz, rn, rp, rm, wsign,
 
 	// Internal nodes
 
-	wire				plus1;		// Round by adding one 
+	logic				plus1;		// Round by adding one 
 	wire		[52:0]		v1;		// Result + 1 (for rounding)
 	wire		[51:0]		specialres;	// Result of exceptional case 
 	wire		[51:0]		infinityres;	// Infinity or largest real number
@@ -62,9 +57,19 @@ module round(v, sticky, rz, rn, rp, rm, wsign,
 	//	0xx - do nothing
 	//	100 - tie - plus1 if v[2] = 1
 	//	101/110/111 - plus1
-	assign plus1 = (rn & v[1] & (v[0] | sticky | (~v[0]&~sticky&v[2]))) |
-		       (rp & ~wsign) |
-		       (rm & wsign);
+	always @ (FrmE, v, wsign, sticky) begin
+		case (FrmE)
+			3'b000: plus1 = (v[1] & (v[0] | sticky | (~v[0]&~sticky&v[2])));//round to nearest even
+			3'b001: plus1 = 0;//round to zero
+			3'b010: plus1 = wsign;//round down
+			3'b011: plus1 = ~wsign;//round up
+			3'b100: plus1 = (v[1] & (v[0] | sticky | (~v[0]&~sticky&~wsign)));//round to nearest max magnitude
+			default: plus1 = 1'bx;
+		endcase
+	end
+	// assign plus1 = (rn & v[1] & (v[0] | sticky | (~v[0]&~sticky&v[2]))) |
+	// 	       (rp & ~wsign) |
+	// 	       (rm & wsign);
 	//assign plus1 = rn && ((v[1] && v[0]) || (v[2] && (v[1]))) ||
 	//				 rp && ~wsign && (v[1] || v[0]) ||
 	//				 rm && wsign && (v[1] || v[0]);
@@ -84,17 +89,17 @@ module round(v, sticky, rz, rn, rp, rm, wsign,
 	// inputs to the wide muxes can be combined at the expense of more
 	// complicated non-critical control in the circuit implementation.
 
-	assign specialsel =  overflow || underflow || invalid ||
+	assign specialsel =  FmaFlagsM[2] ||  FmaFlagsM[1] ||  FmaFlagsM[4] || //overflow underflow invalid
 							nan || inf;
-	assign specialres = invalid | nan ? nanres : //KEP added nan
-						 overflow ? infinityres : 
+	assign specialres = FmaFlagsM[4] | nan ? nanres : //invalid
+						 FmaFlagsM[2] ? infinityres : //overflow
 						 inf ? 52'b0 :
-						underflow ? 52'b0 : 52'bx;  // default to undefined 
+						 FmaFlagsM[1] ? 52'b0 : 52'bx;  // underflow
 
 	// Overflow is handled differently for different rounding modes
 	// Round is to either infinity or to maximum finite number
 
-	assign infinity = rn || (rp && ~wsign) || (rm && wsign);
+	assign infinity =  |FrmE;//rn || (rp && ~wsign) || (rm && wsign);//***look into this
 	assign infinityres = infinity ? 52'b0 : {52{1'b1}};
 
 	// Invalid operations produce a quiet NaN. The result should
diff --git a/wally-pipelined/src/fpu/FMA/sign.sv b/wally-pipelined/src/fpu/FMA/sign.sv
index f7c7cd541..67d831a87 100644
--- a/wally-pipelined/src/fpu/FMA/sign.sv
+++ b/wally-pipelined/src/fpu/FMA/sign.sv
@@ -10,23 +10,24 @@
 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
-module sign(xsign, ysign, zsign, negsum0, negsum1, bs, ps, killprod, rm, overflow,
-			 sumzero, nan, invalid, xinf, yinf, zinf, inf, wsign, invz, negsum, selsum1, psign);
+module sign(xsign, ysign, zsign, negsum0, negsum1, bs, ps, killprod, FrmE, FmaFlagsM, zzero,
+			 sumzero, nan, xinf, yinf, zinf, inf, wsign, invz, negsum, selsum1, psign, isAdd);
 ////////////////////////////////////////////////////////////////////////////I
  
 	input					xsign;			// Sign of X 
 	input					ysign;			// Sign of Y 
 	input					zsign;			// Sign of Z
+	input					zzero;
+	input					isAdd;
 	input					negsum0;		// Sum in +O mode is negative 
 	input					negsum1;		// Sum in +1 mode is negative 
 	input					bs;				// sticky bit from addend
 	input					ps;				// sticky bit from product
 	input					killprod;		// Product forced to zero
-	input					rm;				// Round toward minus infinity
-	input					overflow;				// Round toward minus infinity
+	input		[2:0]		FrmE;				// Round toward minus infinity
+	input		[4:0]		FmaFlagsM;				// Round toward minus infinity
 	input					sumzero;		// Sum = O
 	input					nan;			// Some input is NaN
-	input					invalid;		// Result invalid
 	input					xinf;			// X = Inf
 	input					yinf;			// Y = Inf
 	input					zinf;			// Y = Inf
@@ -96,10 +97,24 @@ logic tmp;
 	//			 shall be +0 in all rounding attributes EXCEPT roundTowardNegative. Under that attribute, the sign of an exact zero 
 	//			 sum/difference shall be -0.  However, x+x = x-(-X) retains the same sign as x even when x is zero."
  
-	assign zerosign = (~invz && killprod) ? zsign : rm;
+	//assign zerosign = (~invz && killprod) ? zsign : rm;//***look into
+//	assign zerosign = (~invz && killprod) ? zsign : 0;
+	// zero sign
+	//	if product underflows then use psign
+	//	otherwise
+	//		addition
+	//			if cancelation then 0 unless round to -inf
+	//			otherwise psign
+	//		subtraction
+	//			if cancelation then 0 unless round to -inf
+	//			otherwise psign
+
+	assign zerosign = FmaFlagsM[1] ? psign :
+			  (isAdd ? (psign^zsign ? FrmE == 3'b010 : psign) :
+				  (psign^zsign ? psign : FrmE == 3'b010));
 	assign infsign = zinf ? zsign : psign; //KEP 210112 keep the correct sign when result is infinity
 	//assign infsign = xinf ? (yinf ? psign : xsign) : yinf ? ysign : zsign;//original
-	assign tmp = invalid ? 0 : (inf ? infsign :(sumzero ? zerosign : psign ^ negsum));
-	assign wsign = invalid ? 0 : (inf ? infsign :(sumzero ? zerosign : sumneg));
+	assign tmp = FmaFlagsM[4] ? 0 : (inf ? infsign :(sumzero ? zerosign : psign ^ negsum));
+	assign wsign = FmaFlagsM[4] ? 0 : (inf ? infsign :(sumzero ? zerosign : sumneg));
 
 endmodule
diff --git a/wally-pipelined/src/fpu/FMA/special.sv b/wally-pipelined/src/fpu/FMA/special.sv
index 89894ca92..1b83c0daf 100644
--- a/wally-pipelined/src/fpu/FMA/special.sv
+++ b/wally-pipelined/src/fpu/FMA/special.sv
@@ -10,49 +10,49 @@
 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
-module special(x, y, z, ae, xzero, yzero, zzero,
+module special(ReadData1E, ReadData2E, ReadData3E, ae, xzero, yzero, zzero,
 				xnan, ynan, znan, xdenorm, ydenorm, zdenorm, proddenorm, xinf, yinf, zinf);
 /////////////////////////////////////////////////////////////////////////////
 
-	input   	[63:0]     	x;              // Input x
-	input     	[63:0]     	y;           	// Input Y
-	input      	[63:0]    	z;            	// Input z 
+	input   	[63:0]     	ReadData1E;              // Input ReadData1E
+	input     	[63:0]     	ReadData2E;           	// Input ReadData2E
+	input      	[63:0]    	ReadData3E;            	// Input ReadData3E 
 	input		[12:0]		ae;		// exponent of product
-	output				xzero;		// Input x = 0
-	output				yzero;		// Input y = 0
-	output				zzero;		// Input z = 0
-	output				xnan;		// x is NaN
-	output				ynan;		// y is NaN
-	output				znan;		// z is NaN
-	output				xdenorm;	// x is denormalized
-	output				ydenorm;	// y is denormalized
-	output				zdenorm;	// z is denormalized
+	output				xzero;		// Input ReadData1E = 0
+	output				yzero;		// Input ReadData2E = 0
+	output				zzero;		// Input ReadData3E = 0
+	output				xnan;		// ReadData1E is NaN
+	output				ynan;		// ReadData2E is NaN
+	output				znan;		// ReadData3E is NaN
+	output				xdenorm;	// ReadData1E is denormalized
+	output				ydenorm;	// ReadData2E is denormalized
+	output				zdenorm;	// ReadData3E is denormalized
 	output				proddenorm;	// product is denormalized
-	output				xinf;		// x is infinity
-	output				yinf;		// y is infinity
-	output				zinf;		// z is infinity
+	output				xinf;		// ReadData1E is infinity
+	output				yinf;		// ReadData2E is infinity
+	output				zinf;		// ReadData3E is infinity
 
 	// In the actual circuit design, the gates looking at bits
 	// 51:0 and at bits 62:52 should be shared among the various detectors.
 
 	// Check if input is NaN
 
-	assign xnan = &x[62:52] && |x[51:0]; 
-	assign ynan = &y[62:52] && |y[51:0]; 
-	assign znan = &z[62:52] && |z[51:0];
+	assign xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	assign ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	assign znan = &ReadData3E[62:52] && |ReadData3E[51:0];
 
 	// Check if input is denormalized
 
-	assign xdenorm = ~(|x[62:52]) && |x[51:0]; 
-	assign ydenorm = ~(|y[62:52]) && |y[51:0]; 
-	assign zdenorm = ~(|z[62:52]) && |z[51:0];
+	assign xdenorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0]; 
+	assign ydenorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0]; 
+	assign zdenorm = ~(|ReadData3E[62:52]) && |ReadData3E[51:0];
 	assign proddenorm = &ae & ~xzero & ~yzero; //KEP is the product denormalized
 
 	// Check if input is infinity
 
-	assign xinf = &x[62:52] && ~(|x[51:0]); 
-	assign yinf = &y[62:52] && ~(|y[51:0]); 
-	assign zinf = &z[62:52] && ~(|z[51:0]);
+	assign xinf = &ReadData1E[62:52] && ~(|ReadData1E[51:0]); 
+	assign yinf = &ReadData2E[62:52] && ~(|ReadData2E[51:0]); 
+	assign zinf = &ReadData3E[62:52] && ~(|ReadData3E[51:0]);
 
 	// Check if inputs are all zero
 	// Also forces denormalized inputs to zero.
@@ -60,11 +60,11 @@ module special(x, y, z, ae, xzero, yzero, zzero,
 	// to just check if the exponent is zero.
 	
 	// KATHERINE - commented following (21/01/11)
-	// assign xzero = ~(|x[62:0]) || xdenorm;
-	// assign yzero = ~(|y[62:0]) || ydenorm;
-	// assign zzero = ~(|z[62:0]) || zdenorm;
+	// assign xzero = ~(|ReadData1E[62:0]) || xdenorm;
+	// assign yzero = ~(|ReadData2E[62:0]) || ydenorm;
+	// assign zzero = ~(|ReadData3E[62:0]) || zdenorm;
 	// KATHERINE - removed denorm to prevent outputing zero when computing with a denormalized number
-	assign xzero = ~(|x[62:0]);
-	assign yzero = ~(|y[62:0]);
-	assign zzero = ~(|z[62:0]);
+	assign xzero = ~(|ReadData1E[62:0]);
+	assign yzero = ~(|ReadData2E[62:0]);
+	assign zzero = ~(|ReadData3E[62:0]);
  endmodule
diff --git a/wally-pipelined/src/fpu/FMA/tbgen/results.dat b/wally-pipelined/src/fpu/FMA/tbgen/results.dat
index 4c8bd116c..b1158ef9b 100644
--- a/wally-pipelined/src/fpu/FMA/tbgen/results.dat
+++ b/wally-pipelined/src/fpu/FMA/tbgen/results.dat
@@ -1,16 +1 @@
-0010000000000000 bf4fdffffff7fffe 800ffffffffffffe 800003fbfffffefe 801003fbfffffefe  Wrong zdenorm 308227
-0010000000000000 be6fffffbffffff7 8000000000000000 800000001fffffc0 800000000fffffe0  Wrong 313753
-001ffffffffffffe 3fddfbffffffffff 000ffffffffffffe 000efdfffffffffd 001efdfffffffffd  Wrong zdenorm 551371
-3befe000ffffffff 800ffffffffffffe 0000000000000000 0000000000000000 8000000000000000  Wrong ydenorm unflw 665575
-000007fffffffffe 3f6ffffffe01fffe 000ffffffffffffe 00000007ffffff7e 00100007ffffff7e  Wrong xdenorm zdenorm 768727
-3fdffffffffffffe 000ffffffffffffe 8000000000000001 7feffffffffffff6 0007fffffffffffe  Wrong ydenorm zdenorm 1049939
-7fe0000000000001 4000000000000000 ffefffffffffffff 7ff0000000000000 7cb8000000000000  Wrong w=+inf 2602745
-000fff000000000f 3ff00800001fffff 8010000000000000 7f7bfe007ff8381e 000006ff801ffe0e  Wrong xdenorm 3117277
-8000000000000001 40211275ffe5ee3c 0000000000000001 fcfe24ebffcbdc78 8000000000000008  Wrong xdenorm zdenorm 3148591
-801fffffffffffff bfdffffffffffffe 0000000000021fff 0000000000021ffe 0010000000021ffe  Wrong zdenorm 3537867
-801ffffffffffffe 0010000000000001 0000000000000000 0000000000000000 8000000000000000  Wrong unflw 3564269
-bca0000000000001 000fffffc000001e 8000000000000000 8000000000000001 8000000000000000  Wrong ydenorm 3717769
-bcafffffffffffff 800ffffffffffffe 8000000000000000 0000000000000002 0000000000000001  Wrong ydenorm 3807413
-7fec5fed92358a74 400000001bffffff ffefc0003ffffffe 7ff0000000000000 7fe8ffdb47bad466  Wrong w=+inf 3889689
-bfdfffffffffffff 3fdf1f3616aa73e1 3fd0000000000001 3fd07064f4aac611 3f7c193d2ab1843f  Wrong 4099063
-3fd07dfffffffffe 8010000000000001 0000000000000001 ffe07dfffffffffb 80041f7fffffffff  Wrong zdenorm 4716133
+c3f000200003fffe 0000000000000001 001ffffffffffffe 80cffc400007fffd 80cffc400007fffc  Wrong FmaResultM=  -64 ydenorm 1119653
diff --git a/wally-pipelined/src/fpu/FMA/tbgen/tb b/wally-pipelined/src/fpu/FMA/tbgen/tb
index 47d4a1d234c10008595264aae3be12da9ee68186..7a35f66ad34baa09be743fc2da4a0c740fcf9209 100755
GIT binary patch
delta 3064
zcmb7`e{54#6vtn?U+r*hx2{`P1TGuv5AE1%2ZL-3HpW{T91~|24NJ)iTXD%KxF5ox
zPytaFLilmjpoxi^ImHBRQcR{H`yrUY{-Hq<QHfcim>R(>NCL><dG33C@7>oF5?`{u
zd(Y>5&pG$pd%GrriQw_Let143Ji{k`8qW{g#7WpzFAT!?wC1|`{aeAw)3e1h(_cRN
zy>{j1lX)E@u~XU)GWAhIJ>#32tT)7Jb2OU9I84W{z(-=_5zqUExS6r*#PlmMVbOGL
z{5LYQkl7SBOS1gAHH(2TT>Mi@K91<xt*nM&_D6k3xEbHjRN}%zo<BTcJbWb+-`0Jj
zy<@;<^ww1dBcvXh8YKY|({m8*=(`;}ypC|!#+)=fBf?pdk-)V^tjRSO`i3UIHG_Bz
zk}>0Lph(;}InNU5CL<vrI1{Hf*=Z+1Uy*Q0)Gnio1ieEcuZ)}~K!a&f2SJ-vh?6Qh
zMOdSXNhnT`lR|bmnJynt-W+Z)6h>GwzWqQc*Dt#rC+J5CJr7+FJ26Ypxg;8^H&bn{
zmaL!CRz!t)PR=l6jzF9NimjI!TL@@VTJ$<WYto`PK}#r9DF;LrKza(XfFk00HWK#t
zze*Pr+1mvDKp~~XQG!O(B3%)n4=L0q*YPqz2a_m54v)g(gl$VJ^A!VXPKzc8@=$1%
zoNT2PP*Ga6n;`9j`{WqpjFQQWIJTC+_<M1@n~c8@#?9Br_}G2Yq_$b%maKqp0Qr7p
z2}HaOI=O&Wa7k<ebcmbNh*x4NVY`n%HZ1aAx+h%PH-@PCiezOwQD)0QrxKgM9U=(#
zy+s&jy;OjhBW-hIy>ua4fL%I|k+E>Ws1Y%3zM~c7{bIB0hUXXG<iiZ#p_{tI*LU#?
z#<y0tb_F`u1^NRX4%MORWsX<M`)YF;1dl|#k0n(ceqbysYU<riT&f&fSe6BGnTO3~
z7(8zJF4D9;(Aw2E(9^%6z1mx|-0MenI|@_Q<(?YWUyHz>Jo??CKnOzFrQ9Bl)=}0J
z-C&B&E9zR42_+$zQ-pg`gjH!1f>qMtf`Xce6i+VCC9I1w3+`wQ+DqG5SgRX(pilcy
zjoe=kC#+vT7~0Xh9Tvae8J0xJWqAGS_$|^p=mf-;K7p5mO@Zci2c6EvyU2oJ6P(H>
zV5_;JTA7lLvwl=prz&3DJ~tHaaZBZSINV__PTAxXsk{WWRH}BL%Y{%ljGV$osOw5o
zh`c>iv;}Z_$p(?dlW-)OvKoBVycpjzyQw{s>-TbQc^9f+tf<^55bARYZ4=I=eo1gw
zZ+Cx}Gq}@@N)^Al^72kp>R!^<y)D$$=?wJ1duyoQm6Ym9&qeP{atZM2LPsN|uGrJn
zy91R<i3E3Q`yYF}@UcRNE7e=>wED1kIea;dx7<m!H(Y6>#nB)Y-qaJ=*0-U3nIA2#
zL#zv_+Rz<(tp`?5s!#Fv`tg9J%p$f<Y(X-T$B#!Wi;R+g^2-6oiybbyFWsS_(iS<o
z<ZZI5yq|rt_eSf}xk_xj!|HrSnbyJ1wFFv}WT}-!)#}UtPi-nu<*qDI<$iUb|B1PG
zs@2CzoJCaSlsb04xJ_Gn^)H?eL(hkA@_aMAPu$}9VR&EohvzTAd)XaaW3y{E;()CZ
zK2O*jr8mH}DjQgX!StrKF)uq~Y4%e&I%XZ1I^pl$ZTz#XDGNaaZOk)&uNIpY)@#oi
zVyz4R$n>0rAE~KN24iF<(%MZ-7#}FJWaKl^*nzUU8qG&|u>3P^)PPIvBM=i$+ef??
zQ=|*E43kfV%uMF10DA$G$J86}Cyw{DRoSr`ry)msG6%1(T$(Et20;&2Ru@S1Oc+G<
cxp{cHa;aYV{jOnG=%es2lswT`1MA564|^vDC;$Ke

delta 3013
zcmaKue{2(F7{~9rLEACbA8WDebbHxk?Vw}rWD_>(x{PW=kQj7{y39D-<`(BVI!1r6
zQgDEQWeNJCA^xFY1i?r|`VUUB4IvqzCYWfP!9-$&)HroPehdW8=efIH-;UxX?Y-~w
z`9442%jFUsiH<!Nw95)P@mluQPh*B$tF+0rdc;L8J;MK-Uz}BX@AD(W?_ViyD8Kj5
zaO~^abMbwu_p-HnbRNz(af;~Tb!wh(JO<mb<M5X_bWad`yS$f1PoilQO;j>Xj-AGx
z8Fv%jY0UDwXD$a}yccc`JwaodW=orj<F*|04S6s5c1<MC+!cf!<GLN6&7oH{U#Py<
z(W6?+%F7T1=m`vvIDZGC4ZriU0JkCU<me3+9+luUW<;pgQ$8m@Ho}AFs8!E|=|?3<
zMlk58okcIEp&Ay|r=e9WdQ?WfU8hDCU`)(8whknTSeRjEg>@l&i9tpM#Sk@SL~kRq
zGbk1CAfovU%9aAgppY+-UHw;T8f$D)l8qz!kwMK0vKRoJWDrqM2+@IzXg{KzDHIz?
zxt&G!T8c4f8qqThDpQhKjDV^cRI4BlA}fPdC}=Ap;kFPHPa2zUP}n%K-)^VoF{L0)
zKA>|l8l8ci^6)h>4yioLP2jMPLCcj`Aw;ogMs@<(`iy7>(NhdstVCRH2IOFnLqVO0
z4EG~E|9!}A+)DMEs_`tMiy4t-0ibaPJ+CD5Av%~59Y(Y}g<cs+xoI8(=1(yObs~C>
zK`WJHXA!N)h%^>JMYkwF&!qO@I!js~#&u#wv}+1r{jIo;b>jN?3=X1cT6{@NfJHfB
zyGXo~__S!0{J)}86wsje4v$XwvT{q(X<wc9LjT;s=r{bv0^gu_8U^CpZ0e@?HrxIw
zQ}~(%O3*(rXt|PaA`u0B(szTno)a+;Zm8+bsLIOJxC7X^)4F1gdh$$<Oy&`;$v0eq
z_h;9XUv^#eow}Rl8=TT4ez-w5<h@xMB5qQ%%+|T6uP%opaD`_ZBD6+V8VmG*eNme%
z3PjR&ucz&L*<E{UpgSCB?*kj8S?`nsB+Y&8-9VDo_2FJHxJgw?2&Ufd{=O1dx~$jV
zx3R|`z{KcW>T>2#zwWD8u(_tHwz{f?l$DWzU~{#r*4a`=a$v6Fr49A8Vk2cCRu{To
z7nXHlRu{fs7m;-lNoSN2M;IYh8ERw6bmd}Qaz0W|Hp9{hB|3-;T8@%h5>l$whUEsg
z*awnjNd9si=nu<u|1eBL?iFWl-&_q-f7;~;VX!D!LhRCz305Kx*HvCl$YMf7t;-?i
zjVg6;+O7_}ePIwg1s{8mYK;}rpq(wm?Zzggp*x@n$Rw2%g`fii#4b)!^h1^Gk?cqE
zkefgc(M25UY!`XLEs~2KMvRRovjk~z{zCX%p!N9`){rCYAQ1-%I!J3zU%5CDEp`#4
zf9Km42i+Bs_JE(1NCc-PQkZkH6ZxFz3np7ZiYBX;Pk|muqsam#8lksLwmjLlt7lVd
zcUK#AnTw6$;fVSCo7w{%-TokLHJ9dzmj0eL+2k^t=uz`LZL+o?^;m2LP<dBR2V1yQ
zd5~@u>5>P~am&Mekp5z^7Y5yZU9YZfU7INeDL_?y!T+naimDGp)rS6!4~TV1R0#!k
zebAk*ia%y)QkATl5`+P0&h)1stbsfKmmqwE`|E;m2JYLh(@(5r{5bv2S_%Jrp{=9|
zq<S^5hCKaFRpb1*S@YDnY7MsvOl|P<U8AcDpPbWsO%PP^1BHGSJytkC^+g`lUR``$
z(Uol1UiciGePwYvZhuC*p39}%O3hgY&J*8OdXwj!G`#3z)gB!!DLVu)>G`rlRflJ}
z7Qr)UU_xfg`6|F}<mPikM?bW^tJ16Ewe~!<DxjgOE0^XZ3xl9<RMr@i_3YP4-rYI$
ZeC1MY>SLUDKCbn^TOTh^yuoS9`VR&`+p7Qo

diff --git a/wally-pipelined/src/fpu/FMA/tbgen/tb.c b/wally-pipelined/src/fpu/FMA/tbgen/tb.c
index fa3b5e71e..891a25da2 100644
--- a/wally-pipelined/src/fpu/FMA/tbgen/tb.c
+++ b/wally-pipelined/src/fpu/FMA/tbgen/tb.c
@@ -20,19 +20,19 @@ void main() {
 		// b68ffff8000000ff_3f9080000007ffff_b6307ffbe0080080_00001
                 char ch;
 		int i,j,n;
-		char x[17];
-		char y[17];
-		char z[17];
+		char ReadData1E[17];
+		char ReadData2E[17];
+		char ReadData3E[17];
 		char ans[81];
 		char flags[3];
-		int rn,rz,rm,rp;
-		long stop = 4099063;
+		int FrmE;
+		long stop = 1119653;
 		int debug = 1;
 		//my_string = (char *) malloc (nbytes + 1);
 		//bytes_read = getline (&my_string, &nbytes, stdin);
 	
 
-		for(n=0; n < 613; n++) {//613 for 10000
+		for(n=0; n < 305; n++) {//613 for 10000
 			if(getline(&ln,&nbytes,fp) < 0 || feof(fp)) break;
 			if(k == stop && debug == 1) break;
 			k++;
@@ -41,71 +41,59 @@ void main() {
 
 		if(!feof(fp)) {
 
-			strncpy(x,   ln,     16); x[16]=0;
-			strncpy(y,    &ln[17], 16); y[16]=0;
-			strncpy(z,  &ln[34], 16); z[16]=0;
-			// fprintf(stdout,"[%s]\n[%s]\n", ln,z);
+			strncpy(ReadData1E,   ln,     16); ReadData1E[16]=0;
+			strncpy(ReadData2E,    &ln[17], 16); ReadData2E[16]=0;
+			strncpy(ReadData3E,  &ln[34], 16); ReadData3E[16]=0;
+			// fprintf(stdout,"[%s]\n[%s]\n", ln,ReadData3E);
 			strncpy(ans,  &ln[51], 16); ans[16]=0;
 			strncpy(flags,&ln[68],2);   flags[2]=0;
 		
-			// fprintf(stdout,"[%s]\n[%s]\n", ln,z);
-			fprintf(fq,"    x = 64'h%s;\n",x); 
-			fprintf(fq,"    y = 64'h%s;\n",y); 
-			fprintf(fq,"    z = 64'h%s;\n",z);
+			// fprintf(stdout,"[%s]\n[%s]\n", ln,ReadData3E);
+			fprintf(fq,"    ReadData1E = 64'h%s;\n",ReadData1E); 
+			fprintf(fq,"    ReadData2E = 64'h%s;\n",ReadData2E); 
+			fprintf(fq,"    ReadData3E = 64'h%s;\n",ReadData3E);
 			fprintf(fq,"    ans = 64'h%s;\n", ans);
 			// fprintf(fq,"    flags = 5'h%s;\n", flags);
 		
 
 			{
 				//rn=1; rz=0; rm=0; rp=0;
-				fprintf(fq,"    rn = %d;\n",1);
-				fprintf(fq,"    rz = %d;\n", 0);
-				fprintf(fq,"    rm = %d;\n", 0);
-				fprintf(fq,"    rp = %d;\n", 0);
-			}
-			{
-				fprintf(fq,"    earlyres = 64'b0;\n");
-				fprintf(fq,"    earlyressel = 0;\n");
-			}		
-			{
-
-				fprintf(fq,"    bypsel= 2'b0;\n"); //, bysel);
-				fprintf(fq,"    bypplus1 = 0;\n"); //, byp1);
-				fprintf(fq,"    byppostnorm = 0;\n"); //, bypnorm);
+				fprintf(fq,"    FrmE = 3'b000;\n");
 			}
 			fprintf(fq,"#10\n");
 			// IEEE 754-2008 section 6.3 states "When ether an input or result is NaN, this standard does not interpret the sign of a NaN."
-			//fprintf(fq,"	$fwrite(fp, \"%%h %%h %%h %%h \",x,y,w, ans);\n");	
+			//fprintf(fq,"	$fwrite(fp, \"%%h %%h %%h %%h \",ReadData1E,ReadData2E,FmaResultM, ans);\n");	
 			fprintf(fq,"    // IEEE 754-2008 section 6.3 states: \"When ether an input or result is NaN, this\n");
 			fprintf(fq,"    //                                     standard does not interpret the sign of a NaN.\"\n");
-			fprintf(fq,"	wnan = &w[62:52] && |w[51:0]; \n");
-			fprintf(fq,"	xnan = &x[62:52] && |x[51:0]; \n");
-			fprintf(fq,"	ynan = &y[62:52] && |y[51:0]; \n");
-			fprintf(fq,"	znan = &z[62:52] && |z[51:0]; \n");
+			fprintf(fq,"	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; \n");
+			fprintf(fq,"	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; \n");
+			fprintf(fq,"	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; \n");
+			fprintf(fq,"	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; \n");
 			fprintf(fq,"	ansnan = &ans[62:52] && |ans[51:0]; \n");
-			fprintf(fq,"	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; \n");
-			fprintf(fq,"	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;\n");
-			fprintf(fq,"	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; \n");
-			// fprintf(fq,"    if(!(~(|x[62:52]) && |x[51:0] || ~(|y[62:52]) && |y[51:0])) begin\n"); 
+			fprintf(fq,"	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; \n");
+			fprintf(fq,"	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;\n");
+			// fprintf(fq,"	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; \n");
+			// fprintf(fq,"    if(!(~(|ReadData1E[62:52]) && |ReadData1E[51:0] || ~(|ReadData2E[62:52]) && |ReadData2E[51:0])) begin\n"); 
 																							// not looknig at negative zero results right now
-			//fprintf(fq,"	  if( (nan && (w[62:0] != ans[62:0])) || (!nan && (w != ans)) && !(w == 64'h8000000000000000 && ans == 64'b0)) begin\n"); 
-			// fprintf(fq,"	if( (nan && (w[62:0] != ans[62:0])) || (!nan && (w != ans)) ) begin\n"); 
-			fprintf(fq,"	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin\n"); 
-			fprintf(fq,"		$fwrite(fp, \"%%h %%h %%h %%h %%h  Wrong \",x,y, z, w, ans);\n");
+			//fprintf(fq,"	  if( (nan && (FmaResultM[62:0] != ans[62:0])) || (!nan && (FmaResultM != ans)) && !(FmaResultM == 64'h8000000000000000 && ans == 64'b0)) begin\n"); 
+			// fprintf(fq,"	if( (nan && (FmaResultM[62:0] != ans[62:0])) || (!nan && (FmaResultM != ans)) ) begin\n"); 
+			fprintf(fq,"	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin\n"); 
+			fprintf(fq,"		$fwrite(fp, \"%%h %%h %%h %%h %%h  Wrong \",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);\n");
 			//fprintf(fq,"		$fwrite(fp, \"%%h \",s);\n");
-			fprintf(fq,"		if(w == 64'h8000000000000000) $fwrite(fp, \"w=-zero \");\n");
-			fprintf(fq,"		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, \"xdenorm \");\n");
-			fprintf(fq,"		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, \"ydenorm \");\n");
-			fprintf(fq,"		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, \"zdenorm \");\n");
-			fprintf(fq,"		if(invalid != 0) $fwrite(fp, \"invld \");\n");
-			fprintf(fq,"		if(overflow != 0) $fwrite(fp, \"ovrflw \");\n");
-			fprintf(fq,"		if(underflow != 0) $fwrite(fp, \"unflw \");\n");
-			fprintf(fq,"		if(w == 64'hFFF0000000000000) $fwrite(fp, \"w=-inf \");\n");
-			fprintf(fq,"		if(w == 64'h7FF0000000000000) $fwrite(fp, \"w=+inf \");\n");
-			fprintf(fq,"		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, \"w=sigNaN \");\n");
-			fprintf(fq,"		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, \"w=sigNaN \");\n");
-			fprintf(fq,"		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, \"w=qutNaN \");\n");
-			fprintf(fq,"		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, \"w=qutNaN \");\n");
+			fprintf(fq,"		$fwrite(fp, \"FmaResultM=%%d \",$signed(aligncnt));\n");
+			fprintf(fq,"		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, \"FmaResultM=-zero \");\n");
+			fprintf(fq,"		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, \"xdenorm \");\n");
+			fprintf(fq,"		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, \"ydenorm \");\n");
+			fprintf(fq,"		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, \"zdenorm \");\n");
+			fprintf(fq,"		if(FmaFlagsM[4] != 0) $fwrite(fp, \"invld \");\n");
+			fprintf(fq,"		if(FmaFlagsM[2] != 0) $fwrite(fp, \"ovrflw \");\n");
+			fprintf(fq,"		if(FmaFlagsM[1] != 0) $fwrite(fp, \"unflw \");\n");
+			fprintf(fq,"		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, \"FmaResultM=-inf \");\n");
+			fprintf(fq,"		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, \"FmaResultM=+inf \");\n");
+			fprintf(fq,"		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, \"FmaResultM=sigNaN \");\n");
+			fprintf(fq,"		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, \"FmaResultM=sigNaN \");\n");
+			fprintf(fq,"		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, \"FmaResultM=qutNaN \");\n");
+			fprintf(fq,"		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, \"FmaResultM=qutNaN \");\n");
 
 			fprintf(fq,"		if(ans == 64'hFFF0000000000000) $fwrite(fp, \"ans=-inf \");\n");
 			fprintf(fq,"		if(ans == 64'h7FF0000000000000) $fwrite(fp, \"ans=+inf \");\n");
diff --git a/wally-pipelined/src/fpu/FMA/tbgen/tb.v b/wally-pipelined/src/fpu/FMA/tbgen/tb.v
index 55580c432..aa9bdda6a 100644
--- a/wally-pipelined/src/fpu/FMA/tbgen/tb.v
+++ b/wally-pipelined/src/fpu/FMA/tbgen/tb.v
@@ -2,7226 +2,11997 @@
 module tb;
 
 
- reg 		[63:0]		x;
- reg 		[63:0]		y;
- reg 		[63:0]		z;
- reg 		[63:0]		ans;
- reg 						rn;
- reg 						rz;
- reg 						rm;
- reg 						rp;
- reg 		[63:0]		earlyres;
- reg 						earlyressel;
- reg 		[1:0]			bypsel;
- reg 						bypplus1;
- reg 						byppostnorm;
- wire 	[63:0]		w;
- wire 	[63:0]		wbypass;
- wire 		 			invalid;
- wire 					overflow;
- wire 					underflow;
- wire 					inexact;
+ reg 	[63:0]		ReadData1E;
+ reg 	[63:0]		ReadData2E;
+ reg 	[63:0]		ReadData3E;
+ reg 	[63:0]		ans;
+ reg 	[2:0]		FrmE;
+ wire 	[63:0]		FmaResultM;
+ wire 	[4:0]	 	FmaFlagsM;
 
 integer fp;
 reg wnan;
 reg xnan;
 reg ynan;
 reg znan;
+wire [12:0] aligncnt;
 reg ansnan;
 reg		[105:0]		s;				//	partial product 2	
 reg		[51:0] 		xnorm;
 reg 		[51:0] 		ynorm;
 
 localparam period = 20;  
-fmac UUT(.*);
+fma UUT(.*);
 
 
 initial 
     begin
     fp = $fopen("/home/kparry/riscv-wally/wally-pipelined/src/fpu/FMA/tbgen/results.dat","w");
-    x = 64'hC3E000000003FFFC;
-    y = 64'hB80E0000000FFFFE;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC1F0003F7FFFFFFF;
+    ReadData2E = 64'hB40DC94EA8FD6C48;
+    ReadData3E = 64'h82E1FC6B349D46FE;
+    ans = 64'h360DC9C4DFED9AF4;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"613\n");
+    	$fwrite(fp,"305\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'h0000000000000001;
-    z = 64'hC1C88840B841DACF;
-    ans = 64'hC1C88840B841DACF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC34EFFFFFFFFFF7F;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hBFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1227\n");
+    	$fwrite(fp,"611\n");
     end
-    x = 64'h88800000803FFFFF;
-    y = 64'hC3D000001FFFDFFF;
-    z = 64'hBFB539DBC8083233;
-    ans = 64'hBFB539DBC8083233;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h37E0000001010000;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'h41C000FFFFFFFFEF;
+    ans = 64'h41C000FFFFFFFFEF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1841\n");
+    	$fwrite(fp,"917\n");
     end
-    x = 64'h27F0000008000004;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h3CA0000000000000;
-    ans = 64'h3CA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h402020000FFFFFFE;
+    ReadData3E = 64'hC49CC543222D7A93;
+    ans = 64'hC49CC543222D7A93;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2455\n");
+    	$fwrite(fp,"1223\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'hBFABA4A2A8700F1E;
-    z = 64'hBC0FFFFF7FFFFFFD;
-    ans = 64'hBC0FFFFF7FFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3069\n");
-    end
-    x = 64'hC1FFFFFFFFFF77FF;
-    y = 64'h0010000000000000;
-    z = 64'hC51B6366DC541E43;
-    ans = 64'hC51B6366DC541E43;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3683\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hC3DFE00040000000;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4297\n");
-    end
-    x = 64'hBF6FFFFFFFF7F7FE;
-    y = 64'hC1C000000017FFFE;
-    z = 64'h3FBFFFFFFFFFFF7F;
-    ans = 64'h414000001013FBFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4911\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"5525\n");
-    end
-    x = 64'hB03C000000000006;
-    y = 64'h3810000020000003;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"6139\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h3CA0000000000000;
-    z = 64'hBFC514F1AE3BBAA4;
-    ans = 64'hBFC514F1AE3BBAA4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"6753\n");
-    end
-    x = 64'h3FCDCBA8116A4E79;
-    y = 64'hB4EFF00100000000;
-    z = 64'h3F9000000000FDFE;
-    ans = 64'h3F9000000000FDFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"7367\n");
-    end
-    x = 64'hCF10000001000000;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h0010000000000001;
-    ans = 64'hCBD0000000FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"7981\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hBFCFFFFFFFFFEFBF;
-    z = 64'h37FA7539FC60F374;
-    ans = 64'h37FA7539FC60F374;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"8595\n");
-    end
-    x = 64'h41CFFFFFFFFBFE00;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hFFDFFEFFFFFFBFFF;
-    ans = 64'hFFDFFEFFFFFFBFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"9209\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hFFEFFFFFFFE03FFE;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"9823\n");
-    end
-    x = 64'hC3CFFFFFFFFFFFDB;
-    y = 64'hC020001EFFFFFFFF;
-    z = 64'h41FFFFE0003FFFFF;
-    ans = 64'h4400001F000FFFDC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"10437\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h3FD0000000000001;
-    z = 64'hFFE0000000000001;
+    ReadData1E = 64'hC3DFC000FFFFFFFE;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'hFFE0000000000001;
     ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"11051\n");
+    	$fwrite(fp,"1529\n");
     end
-    x = 64'h47FFFFFBFFFFFFC0;
-    y = 64'hBFE0000000600000;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hC7EFFFFC00BFFFA8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFCFB75018356166;
+    ReadData2E = 64'hB7EFFFFFF7E00000;
+    ReadData3E = 64'hC3DFFFFFFFF78000;
+    ans = 64'hC3DFFFFFFFF78000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"11665\n");
+    	$fwrite(fp,"1835\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h3FE000000000100E;
-    ans = 64'h3FE000000000100E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'hC16FFFFFEEFFFFFF;
+    ans = 64'hC16FFFFFEEFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"12279\n");
+    	$fwrite(fp,"2141\n");
     end
-    x = 64'h4070000001F80000;
-    y = 64'h3FE0000001FE0000;
-    z = 64'hBB81000001000000;
-    ans = 64'h4060000003F60000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h47FCF548236352E4;
+    ReadData2E = 64'h3F900003FDFFFFFF;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h479CF54F5D16B2B7;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"12893\n");
+    	$fwrite(fp,"2447\n");
     end
-    x = 64'h3CA1000000000004;
-    y = 64'h3FE0000000000001;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h3C91000000000005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"13507\n");
+    	$fwrite(fp,"2753\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'h8011000000000000;
-    z = 64'h41EBFFFFFFF7FFFF;
-    ans = 64'h41EBFFFFFFF7FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h40DFFFFFFFFEF7FF;
+    ReadData2E = 64'hC80000007EFFFFFF;
+    ReadData3E = 64'h4008BA14EB49A7C1;
+    ans = 64'hC8F000007EFF7BFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"14121\n");
+    	$fwrite(fp,"3059\n");
     end
-    x = 64'h3FEFFFFFFEFFFFFE;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'hC010000040001000;
-    ans = 64'hC008000080402001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hB810000000600000;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h3FF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"14735\n");
+    	$fwrite(fp,"3365\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'h43EFFFFFFFFFFDFF;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h40600000001FFF7E;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'hC00FFFFFFFFFFDFE;
+    ans = 64'hC00FFFFFFFFFFDFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"15349\n");
+    	$fwrite(fp,"3671\n");
     end
-    x = 64'h3FE9D75B0FC2F002;
-    y = 64'h3FDFFFFFFFF8003F;
-    z = 64'h4147CAF4689FF67D;
-    ans = 64'h4147CAF49C4EAC9C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hDBFFFBFFF8000000;
+    ReadData3E = 64'h4A6FFC00000000FF;
+    ans = 64'h4A6FFC00000000FF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"15963\n");
+    	$fwrite(fp,"3977\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'h3FF0000000000000;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h434FAE5B6ECDD96F;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h434FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"16577\n");
+    	$fwrite(fp,"4283\n");
     end
-    x = 64'h41C0080000100000;
-    y = 64'hBCA7F7FFFFFFFFFE;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFE000003007F7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h43C5385F5ABC1E16;
+    ReadData2E = 64'hC9ABFFFFFFFFFEFF;
+    ReadData3E = 64'h3FC007FFFFFFBFFF;
+    ans = 64'hCD8291536F6499A9;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"17191\n");
+    	$fwrite(fp,"4589\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hC0AFFFBF7FFFFFFE;
-    ans = 64'hC0AFFFBF7FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'h402FFFF000000800;
+    ans = 64'h402FFFF000000800;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"17805\n");
+    	$fwrite(fp,"4895\n");
     end
-    x = 64'hBFF6F566DD405310;
-    y = 64'hC1F254DB3826CB07;
-    z = 64'h407FFFFFFFFFF7F8;
-    ans = 64'h41FA4DD6C47475B5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FC6C487F45FB506;
+    ReadData2E = 64'h43E25F209A1547C0;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h43BA24763E787145;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"18419\n");
+    	$fwrite(fp,"5201\n");
     end
-    x = 64'h47500004000003FE;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"19033\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h456FFFFFFFFFFD7F;
-    z = 64'hBFE42BCBB894D499;
-    ans = 64'hBFE42BCBB894D499;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"19647\n");
-    end
-    x = 64'h480E000000000001;
-    y = 64'h4000000000000001;
-    z = 64'h802FFFC007FFFFFE;
-    ans = 64'h481E000000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"20261\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h4B13504F83E4334E;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"20875\n");
-    end
-    x = 64'hB9607DFFFFFFFFFF;
-    y = 64'h3CADFFFFFFFFFFFE;
-    z = 64'hC39FFFFE00000003;
-    ans = 64'hC39FFFFE00000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"21489\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"22103\n");
-    end
-    x = 64'hC010200000000002;
-    y = 64'h7FE0080000001FFF;
-    z = 64'hBFD0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"22717\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h4010000000000001;
-    z = 64'h450000000001FFFE;
-    ans = 64'h450000000001FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"23331\n");
-    end
-    x = 64'h47EFFFFFFFFFEFFE;
-    y = 64'hC01000FFFFFFFFFF;
-    z = 64'h3EBA653A07ABC2BC;
-    ans = 64'hC81000FFFFFFF7FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"23945\n");
-    end
-    x = 64'hC0A2000000000FFF;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"24559\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h453FFFFC001FFFFF;
-    z = 64'h313867979581E16A;
-    ans = 64'h313867979581E16A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"25173\n");
-    end
-    x = 64'h419000000007FFF0;
-    y = 64'h4340000000000000;
-    z = 64'hC7FFFFDFF7FFFFFF;
-    ans = 64'hC7FFFFDFF7FFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"25787\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hA5FFFFFFDFFFFFFE;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"26401\n");
-    end
-    x = 64'hB80000000000047F;
-    y = 64'hC7EFFFFFFFDFFEFF;
-    z = 64'hBFEF800000000FFF;
-    ans = 64'h3FF03FFFFFDFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"27015\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hC010000000000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"27629\n");
-    end
-    x = 64'h86A0000000050000;
-    y = 64'h2AD69B1275E503A0;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"28243\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h7FE0000000000000;
-    z = 64'hBFF82D736AB2577D;
-    ans = 64'hBFF82D736AB2577D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"28857\n");
-    end
-    x = 64'h43DD6D4736825F34;
-    y = 64'h11E0080000000200;
-    z = 64'hB2E0000000020000;
-    ans = 64'hB2E0000000020000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"29471\n");
-    end
-    x = 64'hB7EE3604B4C64B15;
-    y = 64'h7FE0000000000001;
-    z = 64'hFFE0000000000001;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFE0000000000001;
     ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"30085\n");
+    	$fwrite(fp,"5507\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'hC00FBFFFFFFFFFFE;
-    z = 64'h4010000400020000;
-    ans = 64'h4010000400020000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB48FFFFFFFFF8FFF;
+    ReadData2E = 64'h7FEFC00000000800;
+    ReadData3E = 64'hC34FE0000007FFFE;
+    ans = 64'hF48FBFFFFFFF98DF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"30699\n");
+    	$fwrite(fp,"5813\n");
     end
-    x = 64'hBE1200001FFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h40E56C3F5EA1E0BD;
-    ans = 64'hFE1200001FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h41E0040000FFFFFF;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'hBFE0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"31313\n");
+    	$fwrite(fp,"6119\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'h47F44C67CE14725C;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h41D0040000400000;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'h3FCA69118D0A7A7B;
+    ans = 64'h3FCA69128D4A7A7F;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"31927\n");
+    	$fwrite(fp,"6425\n");
     end
-    x = 64'hBF4F00000000001E;
-    y = 64'hC1EFFFFFFFFFF000;
-    z = 64'hB4B05C323E215212;
-    ans = 64'h414EFFFFFFFFF09E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3F9FEFFFC0000000;
+    ReadData3E = 64'h41DFE000007FFFFF;
+    ans = 64'h41DFE000007FFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"32541\n");
+    	$fwrite(fp,"6731\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'h7FF0000000000001;
-    z = 64'hC000000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"33155\n");
-    end
-    x = 64'hBFE828460CDF6B0D;
-    y = 64'hADAFFBFFFFFFFFFF;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h2DA82541041DCF1F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"33769\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h4007FFFFFFFFFC00;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"34383\n");
-    end
-    x = 64'hC7FFFFFFFFFFFFE7;
-    y = 64'hC7EFFFFEFFFFFFF8;
-    z = 64'hBFF0003C00000000;
-    ans = 64'h4FFFFFFEFFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"34997\n");
-    end
-    x = 64'hBC500BFFFFFFFFFF;
-    y = 64'h8000000000000000;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"35611\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hC01000000000080E;
-    z = 64'hCE9F800000FFFFFF;
-    ans = 64'hCE9F800000FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"36225\n");
-    end
-    x = 64'h47EC1A9C03D9ECB8;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hBEDFFFFFFF7DFFFF;
-    ans = 64'hBEDFFFFFFF7DFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"36839\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h7FF00000FFFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h7FF80000FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"37453\n");
-    end
-    x = 64'hBFCFFFFFFFFFF002;
-    y = 64'hC6700000003BFFFE;
-    z = 64'hBFFFDFFFDFFFFFFF;
-    ans = 64'h46500000003BF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"38067\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h8010000000000000;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"38681\n");
-    end
-    x = 64'hB7F000008000001F;
-    y = 64'h4023FFFC00000000;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hB823FFFC9FFFE027;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"39295\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h380100000000003E;
-    ans = 64'h380100000000003E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"39909\n");
-    end
-    x = 64'h3EF00000000004FF;
-    y = 64'hC35FFFBFFFFFFFEF;
-    z = 64'h800B04413DF080C3;
-    ans = 64'hC25FFFC0000009ED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"40523\n");
-    end
-    x = 64'h407F00003FFFFFFF;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFE;
+    ReadData1E = 64'h94BFEFFFFFFFFFFF;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
     ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"41137\n");
+    	$fwrite(fp,"7037\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'h7FDFFFFFEFFFFF00;
-    z = 64'hB7F0000000021000;
-    ans = 64'hB7F0000000021000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h388802CB750F8A0C;
+    ReadData2E = 64'h7FDBCDA5B681F4BB;
+    ReadData3E = 64'h4014727098BAA500;
+    ans = 64'h7874DCA9E98583AE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"41751\n");
+    	$fwrite(fp,"7343\n");
     end
-    x = 64'hBFDFF7FFFFF7FFFF;
-    y = 64'hBCA0000000000001;
-    z = 64'hC7F82F3AAACD8D77;
-    ans = 64'hC7F82F3AAACD8D77;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h43DFDFFFFFFFFE00;
+    ans = 64'h43DFDFFFFFFFFE00;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"42365\n");
+    	$fwrite(fp,"7649\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'hC5B0004000000100;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h43CFFFFFFFDDFFFF;
+    ReadData2E = 64'hC3FFFFFFFFFFFFFE;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'hC7DFFFFFFFDDFFFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"42979\n");
+    	$fwrite(fp,"7955\n");
     end
-    x = 64'hBFF000FF7FFFFFFF;
-    y = 64'h48BDFFFF7FFFFFFF;
-    z = 64'h3F671AAF77E7002B;
-    ans = 64'hC8BE01DE8FF803FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h434FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"43593\n");
+    	$fwrite(fp,"8261\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h407E0003FFFFFFFE;
+    ReadData2E = 64'hC05C000000000040;
+    ReadData3E = 64'hEEA0000004000003;
+    ans = 64'hEEA0000004000003;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"44207\n");
+    	$fwrite(fp,"8567\n");
     end
-    x = 64'h800FFFFF807FFFFF;
-    y = 64'h43F0000000000005;
-    z = 64'h8000000000000000;
-    ans = 64'h840FFFFF01000008;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h6EE0000000000FDF;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h3FDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"44821\n");
+    	$fwrite(fp,"8873\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'hBFD0000000000001;
-    z = 64'hECAFFFFFF7FFFFEE;
-    ans = 64'hECAFFFFFF7FFFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hAD7000001FFFFF00;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'hC69FFFF400000000;
+    ans = 64'hC69FFFF400000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"45435\n");
+    	$fwrite(fp,"9179\n");
     end
-    x = 64'h6010000000007DFF;
-    y = 64'h3E93A970CD45CF6F;
-    z = 64'h480391CF914CBF65;
-    ans = 64'h5EB3A970CD466A44;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h403FC000000001FF;
+    ReadData3E = 64'h403717FDCAC5D1CA;
+    ans = 64'h403717FDCAC5D1CA;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"46049\n");
+    	$fwrite(fp,"9485\n");
     end
-    x = 64'hC02FFFFFFCFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hC010000000000000;
-    ans = 64'h400FFFFFF9FFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h4015B627851BAB59;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h40156D89E146EAD6;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"46663\n");
+    	$fwrite(fp,"9791\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'h3999E763325E2F3C;
-    z = 64'hC04495126EB489F2;
-    ans = 64'hC04495126EB489F2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC0301FBFFFFFFFFF;
+    ReadData2E = 64'h401000000000FFC0;
+    ReadData3E = 64'hDB30000000020040;
+    ans = 64'hDB30000000020040;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"47277\n");
+    	$fwrite(fp,"10097\n");
     end
-    x = 64'h3EB000040003FFFF;
-    y = 64'hBFE0000000000000;
-    z = 64'h34D7185B3B3DEA47;
-    ans = 64'hBEA000040003FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'h450FF03FFFFFFFFE;
+    ans = 64'h450FF03FFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"47891\n");
+    	$fwrite(fp,"10403\n");
     end
-    x = 64'h0000000000000000;
-    y = 64'hC06FFFFFF7FFDFFF;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"48505\n");
-    end
-    x = 64'h3FEFFFFF7FFFFFFD;
-    y = 64'h3B7FFC0001FFFFFE;
-    z = 64'h7FD000000200001F;
-    ans = 64'h7FD000000200001F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"49119\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"49733\n");
-    end
-    x = 64'hBE0FFDFFFFDFFFFF;
-    y = 64'h3F8FFFF80007FFFF;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"50347\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hBFF0000000000000;
-    z = 64'h3FB0000000000801;
-    ans = 64'h3FB0000000000801;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"50961\n");
-    end
-    x = 64'h40FC000FFFFFFFFF;
-    y = 64'hC7EFFFBFFFFFF7FF;
-    z = 64'h3D4FFFFFFFFF87FF;
-    ans = 64'hC8FBFFD7FFDFF8FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"51575\n");
-    end
-    x = 64'hC1E000000005FFFF;
-    y = 64'hBFF0000000000001;
-    z = 64'hC000000000000001;
-    ans = 64'h41DFFFFFFF8C0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"52189\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h380C1CB161614663;
-    z = 64'hC051FFFFFFFF7FFF;
-    ans = 64'hC051FFFFFFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"52803\n");
-    end
-    x = 64'hB9A00000007FFDFE;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hC1D80003FFFFFFFF;
-    ans = 64'hC1D80003FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"53417\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h434FF0000003FFFE;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3CA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"54031\n");
-    end
-    x = 64'hB9C000000400001F;
-    y = 64'hC01FFFFEFC000000;
-    z = 64'hC1D00007FFFFFBFF;
-    ans = 64'hC1D00007FFFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"54645\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hC000000000000001;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"55259\n");
-    end
-    x = 64'h414E31CF11CCD625;
-    y = 64'h4000000000000081;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"55873\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hFFD0000002FFFFFF;
-    ans = 64'hFFD0000002FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"56487\n");
-    end
-    x = 64'h7FF0000000000040;
-    y = 64'hC00255D9EE601C85;
-    z = 64'h4026389D5E21B837;
-    ans = 64'h7FF8000000000040;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"57101\n");
-    end
-    x = 64'h41E0000003FFE000;
-    y = 64'hC010000000000000;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hC2000000040FE000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"57715\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hC1F080000003FFFF;
-    z = 64'hBFCFFEFFEFFFFFFF;
-    ans = 64'hBFCFFEFFEFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"58329\n");
-    end
-    x = 64'hC1EE67D76FC4673E;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h4DF044E1B605B6E2;
-    ans = 64'h4DF044E1B605B6E2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"58943\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hBF9004000000000F;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h001FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"59557\n");
-    end
-    x = 64'h43CF600000000000;
-    y = 64'hC7E000FFFFF80000;
-    z = 64'hC3F3F7FFFFFFFFFF;
-    ans = 64'hCBBF61F5FFF05000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"60171\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hC340000000000000;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"60785\n");
-    end
-    x = 64'h49F0000000000077;
-    y = 64'hBFE0000000000800;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'hC9E0000000000877;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"61399\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hC7EFFFC000003FFF;
-    ans = 64'hC7EFFFC000003FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"62013\n");
-    end
-    x = 64'h3FE0008FFFFFFFFF;
-    y = 64'h400B829FD71AD041;
-    z = 64'h3E4F6B8CA9EEBB1D;
-    ans = 64'h3FFB839772A6D1C6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"62627\n");
-    end
-    x = 64'h41E008001FFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hC54008001FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"63241\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hBF70000010000020;
-    z = 64'hBF18000200000000;
-    ans = 64'hBF18000200000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"63855\n");
-    end
-    x = 64'h6F4FFFF7FFFFF7FE;
-    y = 64'hFFE0000000000001;
-    z = 64'h3E4FFFFFFFFFFFF3;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"64469\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h3FEFE000000007FF;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h000FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"65083\n");
-    end
-    x = 64'hB42007FFFFFF7FFF;
-    y = 64'h3FF0001FFFFFFFFE;
-    z = 64'hC3FFFFFFFFF87FFE;
-    ans = 64'hC3FFFFFFFFF87FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"65697\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h801FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"66311\n");
-    end
-    x = 64'h406FFFFFFFDF0000;
-    y = 64'h3EF003FFFFFFFFFA;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"66925\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'hFFF0000000000001;
-    z = 64'h3FA0000EFFFFFFFE;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"67539\n");
-    end
-    x = 64'h407FFDFFEFFFFFFE;
-    y = 64'hBBAFFFBFFFFFBFFE;
-    z = 64'h4300000400000FFF;
-    ans = 64'h4300000400000FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"68153\n");
-    end
-    x = 64'h4014000FFFFFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hBFE0000000000000;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"68767\n");
-    end
-    x = 64'h0000000000000000;
-    y = 64'h8000200000000FFF;
-    z = 64'h480FF800000007FE;
-    ans = 64'h480FF800000007FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"69381\n");
-    end
-    x = 64'h3CA4F5D8A9F2E2BD;
-    y = 64'h0000000000000000;
-    z = 64'h3F0C0001FFFFFFFF;
-    ans = 64'h3F0C0001FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"69995\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h37FFFFFFBFFF7FFF;
-    z = 64'h0000000000000000;
-    ans = 64'h0000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"70609\n");
-    end
-    x = 64'hBFB0027907AD9078;
-    y = 64'h46901000000001FE;
-    z = 64'hC3E91A11BDC49CCC;
-    ans = 64'hC650127B80B5723B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"71223\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h8010000000000000;
-    ans = 64'h8010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"71837\n");
-    end
-    x = 64'hB800000007FFF7FF;
-    y = 64'h400FFFFDFFFFFF00;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"72451\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h0010000000000000;
-    z = 64'hE20A6BB7018E117C;
-    ans = 64'hE20A6BB7018E117C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"73065\n");
-    end
-    x = 64'hB87FFFFF8FFFFFFE;
-    y = 64'h3FC00001FFFFDFFF;
-    z = 64'hC7E0007FFFFFFFEF;
-    ans = 64'hC7E0007FFFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"73679\n");
-    end
-    x = 64'hC3D000000000FBFF;
-    y = 64'h0010000000000001;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"74293\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h801FFFFFFE00000E;
-    z = 64'hFFD000000FDFFFFF;
-    ans = 64'hFFD000000FDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"74907\n");
-    end
-    x = 64'h2B4FFEFFFFFFBFFF;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h41EFFFFFEFFFFFFE;
-    ans = 64'h41EFFFFFEFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"75521\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hC0886A6D27B660AD;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"76135\n");
-    end
-    x = 64'hBEC00000004000FF;
-    y = 64'hFFFFFE00000000FF;
-    z = 64'h404C9C600D9E0B67;
-    ans = 64'hFFFFFE00000000FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"76749\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h3CA0000000000001;
-    z = 64'h8000000000000001;
-    ans = 64'h8000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"77363\n");
-    end
-    x = 64'h3FF000043FFFFFFF;
-    y = 64'hC04254549FAA7BB9;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'hC04054597E10F621;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"77977\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hBFD0000000004200;
-    ans = 64'hBFD0000000004200;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"78591\n");
-    end
-    x = 64'hC1C0000FFDFFFFFF;
-    y = 64'hE9100000027FFFFF;
-    z = 64'h350FBFFFC0000000;
-    ans = 64'h6AE000100080027E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"79205\n");
-    end
-    x = 64'hFFF07FFFFFFFFFFB;
-    y = 64'h3FD0000000000000;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hFFF87FFFFFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"79819\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hC030000000003F00;
-    z = 64'hFFE1B726A50BCA05;
-    ans = 64'hFFE1B726A50BCA05;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"80433\n");
-    end
-    x = 64'hC80FFFFF83FFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hB7FFFFFF7FFFFFFE;
-    ans = 64'hC7FFFFFF83FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"81047\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h833DFFF7FFFFFFFE;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"81661\n");
-    end
-    x = 64'hBFC17DF54982AC71;
-    y = 64'h3A1F000008000000;
-    z = 64'h37E1000000000FFF;
-    ans = 64'hB9F0F205A38D9460;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"82275\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h3FE0000000000000;
-    z = 64'h7FFFFFFFFFFFFFFF;
+    ReadData1E = 64'h3FFFF3FFFFFFFFFF;
+    ReadData2E = 64'h41CC8460F8D1AAC0;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
     ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"82889\n");
+    	$fwrite(fp,"10709\n");
     end
-    x = 64'hC80FFFFFEFFFFFDF;
-    y = 64'hAE2FE00007FFFFFE;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hC01FFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"83503\n");
+    	$fwrite(fp,"11015\n");
     end
-    x = 64'h0000000000000001;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h3F39D2473C5B08B5;
-    ans = 64'h3F39D2473C5B08B5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h40040000000FFFFE;
+    ReadData2E = 64'h37EFFFBEFFFFFFFE;
+    ReadData3E = 64'hB7E0000000000081;
+    ans = 64'h37FFFFAEC01FFF78;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"84117\n");
+    	$fwrite(fp,"11321\n");
     end
-    x = 64'hB1CFEDFFFFFFFFFF;
-    y = 64'hFFF000077FFFFFFF;
-    z = 64'h8020000000200002;
-    ans = 64'hFFF800077FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBCA0007FFFFFFEFF;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hBCAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"84731\n");
+    	$fwrite(fp,"11627\n");
     end
-    x = 64'h3E280000000FFFFF;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h3E280000000FFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFB4ECBCB6018A7A;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'h4000000000008FFF;
+    ans = 64'h3FFF589A1A5113AA;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"85345\n");
+    	$fwrite(fp,"11933\n");
     end
-    x = 64'h0000000000000001;
-    y = 64'h7FDFFFFEFFFFFFBF;
-    z = 64'h4000000000080004;
-    ans = 64'h4000000000080005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC0AFFFFFFFF00000;
+    ReadData3E = 64'h3CAFFFF0000000FE;
+    ans = 64'h3CAFFFF0000000FE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"85959\n");
+    	$fwrite(fp,"12239\n");
     end
-    x = 64'h40200008001FFFFE;
-    y = 64'h3FF0000000000001;
-    z = 64'h3F6FFFFFFEFFFF7F;
-    ans = 64'h40200208001FEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h43E01DFFFFFFFFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'h43D01DFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"86573\n");
+    	$fwrite(fp,"12545\n");
     end
-    x = 64'h0000000000000001;
-    y = 64'h37EFFC0000000000;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h434B07BEC47D5B28;
+    ReadData2E = 64'hC00FFFFF7FFEFFFF;
+    ReadData3E = 64'hFFEFFDFFFFE00000;
+    ans = 64'hFFEFFDFFFFE00000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"87187\n");
+    	$fwrite(fp,"12851\n");
     end
-    x = 64'hFFF91C3BFB37550F;
-    y = 64'hBFE000020000007F;
-    z = 64'h402BFFFFF8000000;
-    ans = 64'hFFF91C3BFB37550F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'hC1CFFFFFF8003FFE;
+    ans = 64'hC1CFFFFFF8003FFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"87801\n");
+    	$fwrite(fp,"13157\n");
     end
-    x = 64'h0000000000000001;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h7FEFFFFFFFFFFFFE;
+    ReadData1E = 64'h96FB9A1C04CC829F;
+    ReadData2E = 64'hC03FFFDFFFFFFFC0;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"13463\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"13769\n");
+    end
+    ReadData1E = 64'h4342F61031FB9231;
+    ReadData2E = 64'hFFF1AB8857B4DC76;
+    ReadData3E = 64'hBE8EFFFFFFFFFFEF;
+    ans = 64'hFFF9AB8857B4DC76;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"14075\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h41C29C11EE259365;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h3CA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"14381\n");
+    end
+    ReadData1E = 64'hC0300002000003FF;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h43F2A5B9F0ADEE20;
+    ans = 64'h43F2A5B9F0ADEE20;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"14687\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC1DFFFFFFE0003FE;
+    ReadData3E = 64'h31800800000003FE;
+    ans = 64'h31800800000003FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"14993\n");
+    end
+    ReadData1E = 64'h37FFFFFFFFFF87FF;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h3FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"15299\n");
+    end
+    ReadData1E = 64'h400FFFF100000000;
+    ReadData2E = 64'hC3FFFFFFFFEFFDFF;
+    ReadData3E = 64'h37F00000800001FF;
+    ans = 64'hC41FFFF0FFEFFE07;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"15605\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'h405FFFBFFFE00000;
+    ans = 64'h405FFFBFFFE00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"15911\n");
+    end
+    ReadData1E = 64'hFFEF7FFFFFBFFFFE;
+    ReadData2E = 64'hC03EFFFDFFFFFFFF;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"16217\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"16523\n");
+    end
+    ReadData1E = 64'h403E7FC2EFD29C71;
+    ReadData2E = 64'h40100007FFE00000;
+    ReadData3E = 64'hC3DFFFFFBFF00000;
+    ans = 64'hC3DFFFFFBFF00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"16829\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3FFEC05C47FE2CB6;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h8010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"17135\n");
+    end
+    ReadData1E = 64'hCAAFFEFFFFFC0000;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'hC50FEFFFFFC00000;
+    ans = 64'hCAAFFEFFFFFC0002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"17441\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC069FFFFFFFFFFFE;
+    ReadData3E = 64'h4B10000000FFFFC0;
+    ans = 64'h4B10000000FFFFC0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"17747\n");
+    end
+    ReadData1E = 64'hC020003F7FFFFFFF;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hC031003F7FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"18053\n");
+    end
+    ReadData1E = 64'hC0AFF7F7FFFFFFFF;
+    ReadData2E = 64'hC000001FFFFFFC00;
+    ReadData3E = 64'h7FE949C5A0E93D66;
+    ans = 64'h7FE949C5A0E93D66;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"18359\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h801F1C5A52CE815D;
+    ans = 64'h801F1C5A52CE815D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"18665\n");
+    end
+    ReadData1E = 64'h3EBF1FFFFFFFFFFE;
+    ReadData2E = 64'h3FF000008000007F;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"18971\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h3FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"19277\n");
+    end
+    ReadData1E = 64'h3E120003FFFFFFFE;
+    ReadData2E = 64'hC4A0000000010800;
+    ReadData3E = 64'h47EFFFF7FFF80000;
+    ans = 64'h47EFFFF7FFF80000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"19583\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3DCF24B20E238B01;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h000FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"19889\n");
+    end
+    ReadData1E = 64'h7FD0021FFFFFFFFF;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'h000FFFFFFFF8001F;
+    ans = 64'h7FE0022000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"20195\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h400D52B2928D25B3;
+    ReadData3E = 64'h802DFFFFFFFBFFFF;
+    ans = 64'h802DFFFFFFFBFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"20501\n");
+    end
+    ReadData1E = 64'h47FDFFFFFFFFBFFE;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h481DFFFFFFFFBFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"20807\n");
+    end
+    ReadData1E = 64'hBFF00000801FFFFF;
+    ReadData2E = 64'h40278FE8D20772ED;
+    ReadData3E = 64'hBFDDFFFFFFFC0000;
+    ans = 64'hC0287FE98EB5B94D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"21113\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'hC3AFFFA000000000;
+    ans = 64'hC3AFFFA000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"21419\n");
+    end
+    ReadData1E = 64'h80000000000017FF;
+    ReadData2E = 64'hB7FFFBFFFFFFFDFF;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h401FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"21725\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hBFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"22031\n");
+    end
+    ReadData1E = 64'hBCAFDFFEFFFFFFFF;
+    ReadData2E = 64'h8027F6CED78A3A8C;
+    ReadData3E = 64'hC7EBC49640C1DDFC;
+    ans = 64'hC7EBC49640C1DDFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"22337\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h7FFFFE0000002000;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"22643\n");
+    end
+    ReadData1E = 64'h3FFFFFFFFFFF6FFF;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'hC01000000000000D;
+    ans = 64'h400FFFFFFFFEDFE4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"22949\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC7F0FFFFC0000000;
+    ReadData3E = 64'h3CA000000000000F;
+    ans = 64'h3CA000000000000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"23255\n");
+    end
+    ReadData1E = 64'hC8003BFFFFFFFFFE;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hC8203BFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"23561\n");
+    end
+    ReadData1E = 64'hC1DFF800000000FE;
+    ReadData2E = 64'h001BACBE988157F0;
+    ReadData3E = 64'h7750000FFFFFEFFE;
+    ans = 64'h7750000FFFFFEFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"23867\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'hC34FFFFE000FFFFF;
+    ans = 64'hC34FFFFE000FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"24173\n");
+    end
+    ReadData1E = 64'hBF88E3F9BB250120;
+    ReadData2E = 64'hC3DEAB8649B5B386;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'h4377DB24D1EDE54A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"24479\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h3FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"24785\n");
+    end
+    ReadData1E = 64'hC1DF000000001FFF;
+    ReadData2E = 64'h403CD1841E8DF396;
+    ReadData3E = 64'hB80FFFFFFDFFFFEE;
+    ans = 64'hC22BEAF7FD99A0CA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"25091\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBF8FFFEBFFFFFFFE;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"25397\n");
+    end
+    ReadData1E = 64'hBFE4B5C1CE0FC7F3;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'hBF9000FFFFFFFDFE;
+    ans = 64'hC334B5C1CE0FC7F3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"25703\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h41DFFFFFFFFFFFFF;
+    ReadData3E = 64'h80100200000007FF;
+    ans = 64'h80100200000007FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"26009\n");
+    end
+    ReadData1E = 64'h3B70010000000007;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'h3EC0010000080008;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"26315\n");
+    end
+    ReadData1E = 64'h3C5FF7FEFFFFFFFE;
+    ReadData2E = 64'h3FB000000000F7FF;
+    ReadData3E = 64'h802C007FFFFFFFFF;
+    ans = 64'h3C1FF7FF0001EF80;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"26621\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'h400E96FC00CCC222;
+    ans = 64'h400E96FC00CCC222;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"26927\n");
+    end
+    ReadData1E = 64'hC1DFFFFFEEFFFFFE;
+    ReadData2E = 64'h3E8FE007FFFFFFFF;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'hC07FC007EF10FBBD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"27233\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hBFD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"27539\n");
+    end
+    ReadData1E = 64'hC7EF87569D128E87;
+    ReadData2E = 64'h402DFFBFFFFFFFFF;
+    ReadData3E = 64'h274545C08EA0DAC8;
+    ans = 64'hC82D8EA224942B78;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"27845\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h47B6991E31F48059;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"28151\n");
+    end
+    ReadData1E = 64'h433CCAE453CB7215;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FE00000401FFFFF;
+    ans = 64'h469CCAE453CB7213;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"28457\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h41D8BE43AD466148;
+    ReadData3E = 64'h47F1000400000000;
+    ans = 64'h47F1000400000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"28763\n");
+    end
+    ReadData1E = 64'hC08FFFFFFFE80000;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"29069\n");
+    end
+    ReadData1E = 64'hB7E00000003DFFFF;
+    ReadData2E = 64'h41D07FFFFFFFF800;
+    ReadData3E = 64'hBFC00000000103FE;
+    ans = 64'hBFC00000000103FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"29375\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'h7FDFFFBFFFFFFFF7;
+    ans = 64'h7FDFFFBFFFFFFFF7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"29681\n");
+    end
+    ReadData1E = 64'h1FCFFFFFF00FFFFF;
+    ReadData2E = 64'h3FD00000000047FE;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hBFF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"29987\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'h3CAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"30293\n");
+    end
+    ReadData1E = 64'hC02FFFFFFFFFFE01;
+    ReadData2E = 64'hBFC0000380000000;
+    ReadData3E = 64'hB810020000000080;
+    ans = 64'h400000037FFFFF00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"30599\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBFD007FFFFFFEFFE;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"30905\n");
+    end
+    ReadData1E = 64'h408000000007FBFF;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h453E07A9A16128DC;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"31211\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hA33FFF7FFFF7FFFE;
+    ReadData3E = 64'hE19000007FF00000;
+    ans = 64'hE19000007FF00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"31517\n");
+    end
+    ReadData1E = 64'h401001FFFFFFBFFE;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"31823\n");
+    end
+    ReadData1E = 64'hC09FFFFFFFFBFF00;
+    ReadData2E = 64'h5FDFE08000000000;
+    ReadData3E = 64'h4140000007FFFFFC;
+    ans = 64'hE08FE07FFFFC02F1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"32129\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h404CD362AE8BB385;
+    ans = 64'hFFF8000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"32435\n");
+    end
+    ReadData1E = 64'h912000000008FFFF;
+    ReadData2E = 64'hC3EA190F0D3FE460;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h3FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"32741\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"33047\n");
+    end
+    ReadData1E = 64'hD89FF80000003FFF;
+    ReadData2E = 64'h400000000003FFF7;
+    ReadData3E = 64'h649FFFFFFDFFFF80;
+    ans = 64'h649FFFFFFDFFFF80;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"33353\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC00BA8E5DA51A56B;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h401FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"33659\n");
+    end
+    ReadData1E = 64'hA9B4B64A1320AA03;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h40CFFFFFFF7F7FFE;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"33965\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3177FFFFFEFFFFFF;
+    ReadData3E = 64'hB80FFFFFFFEFFFFB;
+    ans = 64'hB80FFFFFFFEFFFFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"34271\n");
+    end
+    ReadData1E = 64'hC80FFE0000FFFFFF;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"34577\n");
+    end
+    ReadData1E = 64'h37E4E5EB09B9E630;
+    ReadData2E = 64'hC0D000000002007E;
+    ReadData3E = 64'h400FFFFFFFFEFFFC;
+    ans = 64'h400FFFFFFFFEFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"34883\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'h3FFFFFF7FDFFFFFF;
+    ans = 64'h3FFFFFF7FDFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"35189\n");
+    end
+    ReadData1E = 64'hC01EFF7FFFFFFFFF;
+    ReadData2E = 64'h41CFFFFFFFFEFFEF;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hC1FEFF80000707F3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"35495\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'h0010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"35801\n");
+    end
+    ReadData1E = 64'h433C00000000003F;
+    ReadData2E = 64'h2C453D8FBBAA6DE2;
+    ReadData3E = 64'h4000400040000000;
+    ans = 64'h4000400040000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"36107\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"36413\n");
+    end
+    ReadData1E = 64'h7FDBB7A2E8C34984;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'h40300000007FFFEF;
+    ans = 64'h402C890BA3E796AE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"36719\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h41EFFFFBFFFFFFFE;
+    ReadData3E = 64'h7D90080000008000;
+    ans = 64'h7D90080000008000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"37025\n");
+    end
+    ReadData1E = 64'h47FFFFFFDFFFEFFE;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"37331\n");
+    end
+    ReadData1E = 64'hB80CCAF9E864CC74;
+    ReadData2E = 64'hBFCFFFFFFFE000FF;
+    ReadData3E = 64'h1B1FFFFF800FFFFF;
+    ans = 64'h37ECCAF9E8480260;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"37637\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'h43CE000000FFFFFF;
+    ans = 64'h43CE000000FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"37943\n");
+    end
+    ReadData1E = 64'h401FFFFFF3FFFFFF;
+    ReadData2E = 64'hC2A00080001FFFFF;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'hC2D0007FFA1FCFEE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"38249\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h8000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"38555\n");
+    end
+    ReadData1E = 64'h37EF8003FFFFFFFF;
+    ReadData2E = 64'h410FFFFF7FFFFDFE;
+    ReadData3E = 64'h3FF6752E3200448A;
+    ans = 64'h3FF6752E3200448A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"38861\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC3FFFD9E53F69891;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'h4000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"39167\n");
+    end
+    ReadData1E = 64'h401CFA37F61AB9DE;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'hBD48AE33FF42F0BC;
+    ans = 64'hBD48AE33FF42F0BC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"39473\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC7EF912640B3BADD;
+    ReadData3E = 64'hDAF00DFFFFFFFFFF;
+    ans = 64'hDAF00DFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"39779\n");
+    end
+    ReadData1E = 64'h3FD004DE1725440E;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
     ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"88415\n");
+    	$fwrite(fp,"40085\n");
     end
-    x = 64'hC01B2E4B33B41899;
-    y = 64'hBDE0CE2A5F517DF6;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF000000039190E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC7E0800001000000;
+    ReadData2E = 64'h41F0000007FFFFDF;
+    ReadData3E = 64'hBFB0000080FFFFFF;
+    ans = 64'hC9E08000093FFFDE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"89029\n");
+    	$fwrite(fp,"40391\n");
     end
-    x = 64'h0000000000000001;
-    y = 64'h4000000000000001;
-    z = 64'hC3FFFFFFFFFF8006;
-    ans = 64'hC3FFFFFFFFFF8006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'h4F2FE00000000003;
+    ans = 64'h4F2FE00000000003;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"89643\n");
+    	$fwrite(fp,"40697\n");
     end
-    x = 64'hFFD007FFFFFFFC00;
-    y = 64'hBCAD04958D1CA9A2;
-    z = 64'h3FC7FFFFFFFDFFFF;
-    ans = 64'h7C8D1317D7E330B6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC3D4710A80C12BF3;
+    ReadData2E = 64'h0023BF0FB8CF836D;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCA0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"90257\n");
+    	$fwrite(fp,"41003\n");
     end
-    x = 64'hE3F5D3ABA7E0799B;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h8010000000000000;
-    ans = 64'hE415D3ABA7E0799A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"90871\n");
+    	$fwrite(fp,"41309\n");
     end
-    x = 64'h0000000000000001;
-    y = 64'hC3DED4D0B02CD6AA;
-    z = 64'h000C158AC12AC439;
-    ans = 64'h80BED1CB4D7C8BF9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC7FFC00003FFFFFF;
+    ReadData2E = 64'hB7E0003FFFFFFFFF;
+    ReadData3E = 64'hFFEFDFFDFFFFFFFF;
+    ans = 64'hFFEFDFFDFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"91485\n");
+    	$fwrite(fp,"41615\n");
     end
-    x = 64'h4F80041000000000;
-    y = 64'h4010000000000000;
-    z = 64'hB9F7BA96E673F02C;
-    ans = 64'h4FA0041000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC22FFBFFFFFFFFF0;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hBFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"92099\n");
+    	$fwrite(fp,"41921\n");
     end
-    x = 64'h0000000000000001;
-    y = 64'hC00FFFFFFFFFF807;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB80BFFFFFFFFFFFF;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'h00102000FFFFFFFE;
+    ans = 64'h34BC000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"92713\n");
+    	$fwrite(fp,"42227\n");
     end
-    x = 64'hB3DC67A3FC46B7D8;
-    y = 64'hC1CBE5E7797B2F35;
-    z = 64'h76AFC0000FFFFFFF;
-    ans = 64'h76AFC0000FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h382F7F7FFFFFFFFF;
+    ReadData3E = 64'hC0124D9E33621DA3;
+    ans = 64'hC0124D9E33621DA3;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"93327\n");
+    	$fwrite(fp,"42533\n");
     end
-    x = 64'h0000000000000001;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h7FE0000000000000;
+    ReadData1E = 64'h47F00FEFFFFFFFFE;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"42839\n");
+    end
+    ReadData1E = 64'h43E838FD0E6F07BF;
+    ReadData2E = 64'h405FC00001FFFFFF;
+    ReadData3E = 64'hC85FFFFFFC004000;
+    ans = 64'hC85FFFFFFC004000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"43145\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'h37E000001FFF7FFE;
+    ans = 64'h37E000001FFF7FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"43451\n");
+    end
+    ReadData1E = 64'hC034B21C8FB22DE2;
+    ReadData2E = 64'h001FBFFFFFFFFF7F;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h806388B85692C933;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"43757\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"44063\n");
+    end
+    ReadData1E = 64'h3FFFFFBFFFFFFBFF;
+    ReadData2E = 64'h3F00080000000000;
+    ReadData3E = 64'hC3D7F7D4202822B9;
+    ans = 64'hC3D7F7D4202822B9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"44369\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC030000100004000;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'h3FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"44675\n");
+    end
+    ReadData1E = 64'h37E00000007FFF7F;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'hBFE585B80D43FB9F;
+    ans = 64'hBFE585B80D43FB9F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"44981\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h8E4FFFFFBFFFEFFF;
+    ReadData3E = 64'h404FFFFFFFFFE004;
+    ans = 64'h404FFFFFFFFFE004;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"45287\n");
+    end
+    ReadData1E = 64'hC0302000000000FE;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000003;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"45593\n");
+    end
+    ReadData1E = 64'hBEF00000037FFFFF;
+    ReadData2E = 64'h46D010000000FFFF;
+    ReadData3E = 64'hB8B7FFFFFFFFFBFE;
+    ans = 64'hC5D0100003847FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"45899\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'h46C00002000007FF;
+    ans = 64'h46C00002000007FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"46205\n");
+    end
+    ReadData1E = 64'h456FFFFFFFFFE03F;
+    ReadData2E = 64'h3803903647216A9D;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h3D83903647215733;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"46511\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"46817\n");
+    end
+    ReadData1E = 64'hB12FFFDFFFFFFC00;
+    ReadData2E = 64'hBF40000001000040;
+    ReadData3E = 64'hC3E002000FFFFFFF;
+    ans = 64'hC3E002000FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"47123\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h41EF7FFFFFFFFBFE;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hBFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"47429\n");
+    end
+    ReadData1E = 64'h3FC482064B9A8DE5;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'h371FFFFFDFFFFFF7;
+    ans = 64'hBFB482064B9A8DE5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"47735\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3800400007FFFFFE;
+    ReadData3E = 64'h3FF0000010000100;
+    ans = 64'h3FF0000010000100;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"48041\n");
+    end
+    ReadData1E = 64'hFCFA1871A12F52FC;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'h7CEA1871A12F52FC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"48347\n");
+    end
+    ReadData1E = 64'hC347798653317A97;
+    ReadData2E = 64'h3CA000000000000B;
+    ReadData3E = 64'hC3CD17AC96D91948;
+    ans = 64'hC3CD17AC96D91948;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"48653\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'hCC3000007FFFFFFF;
+    ans = 64'hCC3000007FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"48959\n");
+    end
+    ReadData1E = 64'h37FFFF0000400000;
+    ReadData2E = 64'h47EFD7FFFFFFFFFE;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'h3FFFD701403FAFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"49265\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"49571\n");
+    end
+    ReadData1E = 64'hBFDEB61745F36929;
+    ReadData2E = 64'h37E00004000FFFFE;
+    ReadData3E = 64'h434F7FFFFFFFFF7F;
+    ans = 64'h434F7FFFFFFFFF7F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"49877\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h40CFF7FFFFFF8000;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"50183\n");
+    end
+    ReadData1E = 64'hB8016E821E7114DC;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hB7F000000001FFF7;
+    ans = 64'h37F2DD043CE029BF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"50489\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC1E00FFFFFF00000;
+    ReadData3E = 64'hACC10000000FFFFE;
+    ans = 64'hACC10000000FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"50795\n");
+    end
+    ReadData1E = 64'hBFB0010000000800;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h401040040000001F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"51101\n");
+    end
+    ReadData1E = 64'h0010003FFFFFFEFF;
+    ReadData2E = 64'h43F000000040003F;
+    ReadData3E = 64'h4030000007FFBFFF;
+    ans = 64'h4030000007FFBFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"51407\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'hFD4003FFFFFFFFBE;
+    ans = 64'hFD4003FFFFFFFFBE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"51713\n");
+    end
+    ReadData1E = 64'hC02000000020007E;
+    ReadData2E = 64'h4801000000000003;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"52019\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"52325\n");
+    end
+    ReadData1E = 64'h4000004000000FFF;
+    ReadData2E = 64'hB30E2B9A2B23911C;
+    ReadData3E = 64'hCCD50B44486F7C9A;
+    ans = 64'hCCD50B44486F7C9A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"52631\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h41F0000000000FFF;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hBCAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"52937\n");
+    end
+    ReadData1E = 64'hB7FFFFFFFFFFE800;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h401F7FDFFFFFFFFF;
+    ans = 64'h401F7FDFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"53243\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3DCFFFFEFFFFC000;
+    ReadData3E = 64'h4100000003FFFFFE;
+    ans = 64'h4100000003FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"53549\n");
+    end
+    ReadData1E = 64'hBB1F1FFFFFFFFFFF;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hC000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"53855\n");
+    end
+    ReadData1E = 64'h43DFFFFFFC7FFFFF;
+    ReadData2E = 64'hFFD0FFFFFFFFFFDF;
+    ReadData3E = 64'h4000000200000004;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"54161\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'h47EFFF0000100000;
+    ans = 64'h47EFFF0000100000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"54467\n");
+    end
+    ReadData1E = 64'h25EFFFFC000003FF;
+    ReadData2E = 64'hBC5EEAFC4E08B871;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"54773\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h400FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"55079\n");
+    end
+    ReadData1E = 64'hAB4007FFEFFFFFFF;
+    ReadData2E = 64'hC1E3F7FFFFFFFFFF;
+    ReadData3E = 64'h408FFC0000000003;
+    ans = 64'h408FFC0000000003;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"55385\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBFCFFFFE000000FF;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h001FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"55691\n");
+    end
+    ReadData1E = 64'hC3D4002000000000;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h47EFFFFFFF80FFFF;
+    ans = 64'h47EFFFFFFF80FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"55997\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h4EAFFFFFFFFFFFF8;
+    ReadData3E = 64'hBFC630E0EEA8577C;
+    ans = 64'hBFC630E0EEA8577C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"56303\n");
+    end
+    ReadData1E = 64'h7FD00000000FFFFE;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"56609\n");
+    end
+    ReadData1E = 64'h3FCFFDFFEFFFFFFF;
+    ReadData2E = 64'hC3ED67F287D7D96E;
+    ReadData3E = 64'hC8019F8A79446983;
+    ans = 64'hC8019F8A79446983;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"56915\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'h3FD800000001FFFF;
+    ans = 64'h3FD800000001FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"57221\n");
+    end
+    ReadData1E = 64'h4040000007FFFFFF;
+    ReadData2E = 64'h41100000007FFFFF;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h43500000001FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"57527\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hC000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"57833\n");
+    end
+    ReadData1E = 64'h7BFFFFFFFFC00080;
+    ReadData2E = 64'hA9BFFFFFFFF00003;
+    ReadData3E = 64'hBFC003FFFDFFFFFF;
+    ans = 64'hE5CFFFFFFFB00083;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"58139\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC1EDEA3DDF65A262;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h8010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"58445\n");
+    end
+    ReadData1E = 64'h402FF7FFFFFFFBFF;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'hC7EFFFDFFFFDFFFF;
+    ans = 64'hC7EFFFDFFFFDFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"58751\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBFDE20DF253846C3;
+    ReadData3E = 64'hBFCA3D8764E550D3;
+    ans = 64'hBFCA3D8764E550D3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"59057\n");
+    end
+    ReadData1E = 64'hC7700800000FFFFF;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'h47A00800000FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"59363\n");
+    end
+    ReadData1E = 64'h354000001FFFFFE0;
+    ReadData2E = 64'hB80FFFFFFFFFFFDD;
+    ReadData3E = 64'h400FFFFFFFFF7DFE;
+    ans = 64'h400FFFFFFFFF7DFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"59669\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'hAF2FFFFF000FFFFF;
+    ans = 64'hAF2FFFFF000FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"59975\n");
+    end
+    ReadData1E = 64'hEC8FFFFF00400000;
+    ReadData2E = 64'h3DB023FFFFFFFFFE;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'hEA5023FF7F0047FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"60281\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h3FF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"60587\n");
+    end
+    ReadData1E = 64'hC02FFFFFBFFFFFFE;
+    ReadData2E = 64'h40FFCFFFFFFFFFFE;
+    ReadData3E = 64'hBF8FFFFF7FFFE000;
+    ans = 64'hC13FCFFFC45FFFEC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"60893\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h4893E0E3A2BD2F7E;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'h0000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"61199\n");
+    end
+    ReadData1E = 64'h3FEC9DF9DF3C1BE6;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'h345C7595B01ECD68;
+    ans = 64'hC33C9DF9DF3C1BE8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"61505\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC50000000007DFFF;
+    ReadData3E = 64'h3801F71074B2A70B;
+    ans = 64'h3801F71074B2A70B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"61811\n");
+    end
+    ReadData1E = 64'hBFCFFE000000000F;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h432FFE000000000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"62117\n");
+    end
+    ReadData1E = 64'h403FFFFFFFF6FFFF;
+    ReadData2E = 64'h40107FFF7FFFFFFF;
+    ReadData3E = 64'hBB2C000002000000;
+    ans = 64'h40607FFF7FFB5BFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"62423\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'h43DFFFFFFFFFDFFB;
+    ans = 64'h43DFFFFFFFFFDFFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"62729\n");
+    end
+    ReadData1E = 64'h4F600004FFFFFFFF;
+    ReadData2E = 64'h43DFFFFC1FFFFFFF;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h535000030FFF64FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"63035\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hBFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"63341\n");
+    end
+    ReadData1E = 64'h800FFFFFBFFF8000;
+    ReadData2E = 64'hC00FFFFDFFFFFFFB;
+    ReadData3E = 64'hC000960D221BA850;
+    ans = 64'hC000960D221BA850;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"63647\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hBFDFFFFFFFFFF801;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"63953\n");
+    end
+    ReadData1E = 64'h3FF4F85EB86B4EA1;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'h3FC0000000E00000;
+    ans = 64'hFFE4F85EB86B4EA1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"64259\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hC7EFFFFFFFEFFFDF;
+    ReadData3E = 64'hBCA0000200000000;
+    ans = 64'hBCA0000200000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"64565\n");
+    end
+    ReadData1E = 64'hC00000000010000E;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"64871\n");
+    end
+    ReadData1E = 64'h4BFF00000000FFFE;
+    ReadData2E = 64'hBD4000001FFBFFFF;
+    ReadData3E = 64'hC0FFFFFEDFFFFFFF;
+    ans = 64'hC94F00003DF93FFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"65177\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h35800000000001FE;
+    ans = 64'h35800000000001FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"65483\n");
+    end
+    ReadData1E = 64'hC0EFFC0007FFFFFE;
+    ReadData2E = 64'h3F30000000040100;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hC033FE000404007F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"65789\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h3FDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"66095\n");
+    end
+    ReadData1E = 64'h7FEFFFFFFFFDFFF6;
+    ReadData2E = 64'h0020200100000000;
+    ReadData3E = 64'h37F00000101FFFFF;
+    ans = 64'h40202000FFFEFDFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"66401\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hD6803FFFFFFF7FFF;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"66707\n");
+    end
+    ReadData1E = 64'h4071D1D196BCBBB4;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'hC3EAC2BB016C9CB6;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"67013\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'h3FC0400000000002;
+    ReadData3E = 64'h407FFFFFFFFF01FF;
+    ans = 64'h407FFFFFFFFF01FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"67319\n");
+    end
+    ReadData1E = 64'h41DDFBFFFFFFFFFF;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"67625\n");
+    end
+    ReadData1E = 64'h48A2E070EE32D8E0;
+    ReadData2E = 64'hBE1CD75F7BC7FF61;
+    ReadData3E = 64'h3FA2546AE9598A8E;
+    ans = 64'hC6D1036F1A80D304;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"67931\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'hB7F79A72F0763484;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"68237\n");
+    end
+    ReadData1E = 64'h7FEFDA548DF1E93C;
+    ReadData2E = 64'h401FE0000001FFFE;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"68543\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"68849\n");
+    end
+    ReadData1E = 64'h38AC01FFFFFFFFFF;
+    ReadData2E = 64'hC70000400001FFFF;
+    ReadData3E = 64'h620FFFFFFE00FFFF;
+    ans = 64'h620FFFFFFE00FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"69155\n");
+    end
+    ReadData1E = 64'h0000000000000000;
+    ReadData2E = 64'hFFE001FFFFFFFBFF;
+    ReadData3E = 64'h7FE0000000000000;
     ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"69461\n");
+    end
+    ReadData1E = 64'h400FFFB7FFFFFFFE;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'hBEC78A1A64B5276F;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"69767\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h615FFFFFFEFEFFFF;
+    ReadData3E = 64'hC047FFF000000000;
+    ans = 64'hC047FFF000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"70073\n");
+    end
+    ReadData1E = 64'hBCDFFFFFFFFFFFFA;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h801FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"70379\n");
+    end
+    ReadData1E = 64'h400FFFF008000000;
+    ReadData2E = 64'hC0140007FFFFFFFF;
+    ReadData3E = 64'h3CA0FFFFFFFFEFFF;
+    ans = 64'hC033FFFE04FC01FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"70685\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'h3F701FFFFEFFFFFF;
+    ans = 64'h3F701FFFFEFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"70991\n");
+    end
+    ReadData1E = 64'h37EFFFFFEFFE0000;
+    ReadData2E = 64'hBEDFFFF001FFFFFF;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"71297\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'h3CA0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"71603\n");
+    end
+    ReadData1E = 64'hBFC191453FCED168;
+    ReadData2E = 64'hBFCB56D15B3927BA;
+    ReadData3E = 64'h37E000000FFEFFFE;
+    ans = 64'h3F9E04778DA58583;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"71909\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBFEB401F3FDB027F;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"72215\n");
+    end
+    ReadData1E = 64'h469FDFFFFFFFFFFB;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FE00800000007FF;
+    ans = 64'h7FE00800000007FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"72521\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3E0FFC0000007FFF;
+    ReadData3E = 64'h3A4E985408339F37;
+    ans = 64'h3A4E985408339F37;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"72827\n");
+    end
+    ReadData1E = 64'h41CF7FFFFFFBFFFE;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'h01EF8000007BFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"73133\n");
+    end
+    ReadData1E = 64'h986FFEFFFFFFFFFC;
+    ReadData2E = 64'h3F900000100000FF;
+    ReadData3E = 64'h4770000000100FFF;
+    ans = 64'h4770000000100FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"73439\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'hBFFFFFFFFFFFA000;
+    ans = 64'hBFFFFFFFFFFFA000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"73745\n");
+    end
+    ReadData1E = 64'hCDFFFFFFE000003F;
+    ReadData2E = 64'h395ECB367C637D45;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'hC76ECB365D984705;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"74051\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h801FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"74357\n");
+    end
+    ReadData1E = 64'hEB7FFDFFFFFFFFFF;
+    ReadData2E = 64'hC3400000000000FC;
+    ReadData3E = 64'hB81FFFFFD0000000;
+    ans = 64'h6ECFFE00000001F7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"74663\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC1E04000000003FF;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h401FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"74969\n");
+    end
+    ReadData1E = 64'hC035623F6C0776D2;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'hBE3FFFFFFFF0007F;
+    ans = 64'hBE3FFFFFFFF0007F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"75275\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC80FEFFFFFDFFFFE;
+    ReadData3E = 64'h43DFFFFFFFFFBF80;
+    ans = 64'h43DFFFFFFFFFBF80;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"75581\n");
+    end
+    ReadData1E = 64'h43C0007F7FFFFFFF;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h03F0007F7FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"75887\n");
+    end
+    ReadData1E = 64'hC91F80000000001F;
+    ReadData2E = 64'h5944D35BDA88AE28;
+    ReadData3E = 64'hC1C1000000080000;
+    ans = 64'hE274800E6B1E8B84;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"76193\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'hC1FFFBFFFEFFFFFF;
+    ans = 64'hC1FFFBFFFEFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"76499\n");
+    end
+    ReadData1E = 64'h43EFACB926D1E997;
+    ReadData2E = 64'hC3C9C7B965E1B911;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hC7C984A249246658;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"76805\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'h000FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"77111\n");
+    end
+    ReadData1E = 64'hC000000000000FFA;
+    ReadData2E = 64'h41F0000000020007;
+    ReadData3E = 64'hC1E0000008000080;
+    ans = 64'hC204000002021021;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"77417\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBFECD4AA110D5FEE;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hC00FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"77723\n");
+    end
+    ReadData1E = 64'hC80F8001FFFFFFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'hC7F0000000024000;
+    ans = 64'hC7F0000000024004;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"78029\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC02FFFFFFFFEFFDE;
+    ReadData3E = 64'h313FFFFFF000001F;
+    ans = 64'h313FFFFFF000001F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"78335\n");
+    end
+    ReadData1E = 64'h3FDFFF00003FFFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"78641\n");
+    end
+    ReadData1E = 64'hC020000007FFFFF7;
+    ReadData2E = 64'hBF23E9A5A4CF72CF;
+    ReadData3E = 64'h43C003FFFDFFFFFF;
+    ans = 64'h43C003FFFDFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"78947\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'h43DFFFFFFFDFBFFE;
+    ans = 64'h43DFFFFFFFDFBFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"79253\n");
+    end
+    ReadData1E = 64'h3FC0001000000000;
+    ReadData2E = 64'h001000001EFFFFFF;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h3CAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"79559\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h0000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"79865\n");
+    end
+    ReadData1E = 64'h47EFFFFFFFFFFBFF;
+    ReadData2E = 64'h3CA000000000FFC0;
+    ReadData3E = 64'hBFE0000008000800;
+    ans = 64'h44A000000000FDBF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"80171\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h13E00001FFFFFFFE;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'h4000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"80477\n");
+    end
+    ReadData1E = 64'h43DFE45B42DC9C12;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'h2DC0000100000008;
+    ans = 64'h43BFE45B42DC9C14;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"80783\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC3DFFFFFFFFF01FF;
+    ReadData3E = 64'h796FFFFDDFFFFFFF;
+    ans = 64'h796FFFFDDFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"81089\n");
+    end
+    ReadData1E = 64'hBFD000100001FFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"81395\n");
+    end
+    ReadData1E = 64'h47FFFFFE7FFFFFFF;
+    ReadData2E = 64'hBCA46299E234BA33;
+    ReadData3E = 64'hFFD006FFFFFFFFFE;
+    ans = 64'hFFD006FFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"81701\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FDFFFFEFFFFFEFF;
+    ans = 64'h7FDFFFFEFFFFFEFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"82007\n");
+    end
+    ReadData1E = 64'h4020000000007BFE;
+    ReadData2E = 64'h800C000000001FFE;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hBCA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"82313\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"82619\n");
+    end
+    ReadData1E = 64'h3DBFE000000000FE;
+    ReadData2E = 64'h3FE000000003FFFE;
+    ReadData3E = 64'h41AFACA8D40D6262;
+    ans = 64'h41AFACA8D40D6262;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"82925\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC07FFFC00001FFFF;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hBFF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"83231\n");
+    end
+    ReadData1E = 64'hBFC28E53D1BD64E5;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'hC3C8A4AE1DD1A4C3;
+    ans = 64'hC3C8A4AE1DD1A4C3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"83537\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC2E18FA43B6CB543;
+    ReadData3E = 64'h401000000000006E;
+    ans = 64'h401000000000006E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"83843\n");
+    end
+    ReadData1E = 64'hFFFFFFFFFF800007;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFF800007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"84149\n");
+    end
+    ReadData1E = 64'h3FDFFFE1FFFFFFFE;
+    ReadData2E = 64'h3B90004000000006;
+    ReadData3E = 64'h381F000000000001;
+    ans = 64'h3B800030FFC40005;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"84455\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h311000001FFEFFFF;
+    ans = 64'h311000001FFEFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"84761\n");
+    end
+    ReadData1E = 64'h3FE0000010007FFF;
+    ReadData2E = 64'h37D000000003EFFE;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h37C0000010046FFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"85067\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"85373\n");
+    end
+    ReadData1E = 64'hC7D2FD16AA96B96D;
+    ReadData2E = 64'hC1D000010000003F;
+    ReadData3E = 64'h37EFD7FFFFFFFFFF;
+    ans = 64'h49B2FD17DA682461;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"85679\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h5F3FFE000000001F;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h3FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"85985\n");
+    end
+    ReadData1E = 64'hB804815C1063C1E2;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'h449FFFC0000000FE;
+    ans = 64'h449FFFC0000000FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"86291\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h41FFFFFF00000004;
+    ReadData3E = 64'hDFB0000800000007;
+    ans = 64'hDFB0000800000007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"86597\n");
+    end
+    ReadData1E = 64'hC0F04000001FFFFF;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h433FFFFFFFFEFC00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"86903\n");
+    end
+    ReadData1E = 64'h37FAF5DF12024664;
+    ReadData2E = 64'h4CDFFFFFFFFFC010;
+    ReadData3E = 64'hBF47F140CD2482F2;
+    ans = 64'h44EAF5DF12021086;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"87209\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hC1F00000002001FF;
+    ans = 64'hC1F00000002001FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"87515\n");
+    end
+    ReadData1E = 64'h43EFFFFFFFBDFFFF;
+    ReadData2E = 64'h40164FFAE8166810;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'h44164FFAE7E8631A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"87821\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"88127\n");
+    end
+    ReadData1E = 64'h40310000000003FE;
+    ReadData2E = 64'h308100000000003F;
+    ReadData3E = 64'h526FFFFFFFEF8000;
+    ans = 64'h526FFFFFFFEF8000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"88433\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBFCF31CDEA17BD81;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"88739\n");
+    end
+    ReadData1E = 64'h801647EF7B8F4A27;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'hC02F0007FFFFFFFF;
+    ans = 64'hC02F0007FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"89045\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC7FE9B19A720FB35;
+    ReadData3E = 64'h48000000001FFFEE;
+    ans = 64'h48000000001FFFEE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"89351\n");
+    end
+    ReadData1E = 64'h71A7FFFFFFFFFBFF;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'h71B7FFFFFFFFFBFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"89657\n");
+    end
+    ReadData1E = 64'h434E071E5491DB00;
+    ReadData2E = 64'hC3C233D6818376D1;
+    ReadData3E = 64'h40000FFFFDFFFFFF;
+    ans = 64'hC72114A5B10BB81C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"89963\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'hBFEFFC000001FFFF;
+    ans = 64'hBFEFFC000001FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"90269\n");
+    end
+    ReadData1E = 64'h45BFFFFFFFBFFF7E;
+    ReadData2E = 64'h80000001FFFFFFEF;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"90575\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h4340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"90881\n");
+    end
+    ReadData1E = 64'h3E299454FA252AF8;
+    ReadData2E = 64'hC7EFFFFFFFFDFE00;
+    ReadData3E = 64'h0CF00001FF000000;
+    ans = 64'hC6299454FA239019;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"91187\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h0B3FFFFFFF0001FF;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"91493\n");
+    end
+    ReadData1E = 64'h801C00000000FFFF;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'h380FFFFF0000000F;
+    ans = 64'h380FFFFF0000000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"91799\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h434FFF7FFF000000;
+    ReadData3E = 64'hBE90000003FF7FFE;
+    ans = 64'hBE90000003FF7FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"92105\n");
+    end
+    ReadData1E = 64'h43F0400000007FFF;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h4410400000007FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"92411\n");
+    end
+    ReadData1E = 64'h3FCFFFFFFFFFFFFE;
+    ReadData2E = 64'hB8BFFFFF000000FF;
+    ReadData3E = 64'hFFFB36B5B1C510AD;
+    ans = 64'hFFFB36B5B1C510AD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"92717\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'hFFD0207FFFFFFFFF;
+    ans = 64'hFFD0207FFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"93023\n");
+    end
+    ReadData1E = 64'h4850000040007FFE;
+    ReadData2E = 64'hBD4000000000004F;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"93329\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"93635\n");
+    end
+    ReadData1E = 64'hBFC3FFFFEFFFFFFF;
+    ReadData2E = 64'hBCD0000000100000;
+    ReadData3E = 64'hBFDFFFFFFF800FFE;
+    ans = 64'hBFDFFFFFFF800FFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
@@ -7230,7189 +12001,11971 @@ initial
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
     	$fwrite(fp,"93941\n");
     end
-    x = 64'hC3DFFFEDFFFFFFFF;
-    y = 64'h3FD0001FFFFFEFFF;
-    z = 64'h3FE0000000000001;
-    ans = 64'hC3C00016FFEDEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hE3E000000001FFFF;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCA0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"94555\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h4340000023FFFFFF;
-    ans = 64'h4340000023FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"95169\n");
-    end
-    x = 64'h40FFFDFF7FFFFFFF;
-    y = 64'hC34FFDFFFFFFFFEF;
-    z = 64'h7E0FFEFFFFEFFFFF;
-    ans = 64'h7E0FFEFFFFEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"95783\n");
-    end
-    x = 64'hC1DFFFFFFFFFFF7E;
-    y = 64'h4340000000000001;
-    z = 64'h8000000000000001;
-    ans = 64'hC52FFFFFFFFFFF80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"96397\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h3FF00003FFFEFFFF;
-    z = 64'hFFEFF000000001FF;
-    ans = 64'hFFEFF000000001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"97011\n");
-    end
-    x = 64'hC15000000010001F;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h47F55792228596A0;
-    ans = 64'h47F557922285969F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"97625\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hBFAAABC3854D8AAA;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"98239\n");
-    end
-    x = 64'hB7E01FFFFFFFF800;
-    y = 64'hC7F2000000000003;
-    z = 64'hBFEF7FFEFFFFFFFF;
-    ans = 64'hBFDAB7FE000011F8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"98853\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h7FE0000000000001;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"99467\n");
-    end
-    x = 64'hFFFFE0000000000E;
-    y = 64'hBCB0FFFFFFF7FFFF;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'hFFFFE0000000000E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"100081\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h43C0000000FFFFFB;
-    ans = 64'h43C0000000FFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"100695\n");
-    end
-    x = 64'h46C5E1DB918AAA60;
-    y = 64'hC05FF77FFFFFFFFF;
-    z = 64'h3EEE3AB867132DBF;
-    ans = 64'hC735DC0B9338018A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"101309\n");
-    end
-    x = 64'hC3EF7FF7FFFFFFFF;
-    y = 64'h7FF0000000000000;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"101923\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hFDD0000010000FFE;
-    z = 64'hC95336CB2C26A80E;
-    ans = 64'hC95336CB2C26A80E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"102537\n");
-    end
-    x = 64'hC121216432DE4B7B;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h3FBE000000003FFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"103151\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h4446AF233378CEC0;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"103765\n");
-    end
-    x = 64'h4050020000000100;
-    y = 64'h40F64E3F0BD07E03;
-    z = 64'h41E07FFFFFFFFFBF;
-    ans = 64'h41E08B288469D8BC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"104379\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h8000000000000000;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"104993\n");
-    end
-    x = 64'h47EE78ADB65F42F6;
-    y = 64'h8638A91112ECACCA;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"105607\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h8000000000000001;
-    z = 64'h41F0010FFFFFFFFF;
-    ans = 64'h41F0010FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"106221\n");
-    end
-    x = 64'h3FD43D5700152CCF;
-    y = 64'h40DA29B21651007D;
-    z = 64'h3420000004003FFE;
-    ans = 64'h40C08C35EADAA763;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"106835\n");
-    end
-    x = 64'h3FEFFFFFFFFFF0FF;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"107449\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hB81FFFC0007FFFFE;
-    z = 64'hC1C00000017FFFFF;
-    ans = 64'hC1C00000017FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"108063\n");
-    end
-    x = 64'hBF8174D88196FAA3;
-    y = 64'h8010000000000000;
-    z = 64'h381FFFFFEFFFFFFF;
-    ans = 64'h381FFFFFEFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"108677\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h4010000003FFEFFF;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"109291\n");
-    end
-    x = 64'hEB2F000000000000;
-    y = 64'hA174D8D7ABF83504;
-    z = 64'hC2D90E3B93B7E7E0;
-    ans = 64'h4CB43210EE98735C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"109905\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"110519\n");
-    end
-    x = 64'hC1F367DA2CF3586B;
-    y = 64'hC1DF800000007FFF;
-    z = 64'h3CA0000000000000;
-    ans = 64'h43E31A3AC43FD8A8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"111133\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hBCA0000000000000;
-    z = 64'h3FDF5FE30D19D2F1;
-    ans = 64'h3FDF5FE30D19D2F1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"111747\n");
-    end
-    x = 64'hC85F87FFFFFFFFFF;
-    y = 64'h45188A3DBE3CCC18;
-    z = 64'h3E6FFFFFFF01FFFF;
-    ans = 64'hCD882E3756B3681A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"112361\n");
-    end
-    x = 64'h41E00000FFBFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"112975\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h40001FFFFDFFFFFE;
-    z = 64'hC05FFFFFFF8007FF;
-    ans = 64'hC05FFFFFFF8007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"113589\n");
-    end
-    x = 64'hC7F00000FFFFFBFF;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h38000000002007FE;
-    ans = 64'h44B00000FFFFFBFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"114203\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h404FFF7F7FFFFFFF;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"114817\n");
-    end
-    x = 64'h3FF0000000040001;
-    y = 64'h381DCC6F8DD95714;
-    z = 64'hBFDE91054BF087B4;
-    ans = 64'hBFDE91054BF087B4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"115431\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"116045\n");
-    end
-    x = 64'h55BA9A28FB6E818D;
-    y = 64'hC91FFFC000000200;
-    z = 64'h0010000000000001;
-    ans = 64'hDEEA99F3C71C8C5A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"116659\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h801FFFFFFFFFBFC0;
-    ans = 64'h801FFFFFFFFFBFC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"117273\n");
-    end
-    x = 64'h41D0000008003FFE;
-    y = 64'h38100000FFF7FFFF;
-    z = 64'h3CAFFFFBFFF80000;
-    ans = 64'h3CAFFFFBFFF80200;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"117887\n");
-    end
-    x = 64'hC1F010000000000F;
-    y = 64'hBFE0000000000001;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000040400001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"118501\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h3FB9B590EB570621;
-    z = 64'hC00FFFC00001FFFE;
-    ans = 64'hC00FFFC00001FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"119115\n");
-    end
-    x = 64'h4220000000403FFF;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h3FF000200000003F;
-    ans = 64'hC2200000003E3FFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"119729\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h401003FFFFFFFF7F;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"120343\n");
-    end
-    x = 64'h2890000100003FFF;
-    y = 64'hB83F246C2E31EA5B;
-    z = 64'h0D4001FFFFFFFFE0;
-    ans = 64'hA0DF246E207929CE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"120957\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hBFF0000000000001;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"121571\n");
-    end
-    x = 64'h3F0C00FFFFFFFFFF;
-    y = 64'hC7FFE0000000001F;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hC71BE4FF0000001A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"122185\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hBF9000000001FFF0;
-    ans = 64'hBF9000000001FFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"122799\n");
-    end
-    x = 64'h3FE0013FFFFFFFFF;
-    y = 64'hC1DF7FFFE0000000;
-    z = 64'hBBEE000000000001;
-    ans = 64'hC1CF8275DFFD7FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"123413\n");
-    end
-    x = 64'hBE900000E0000000;
-    y = 64'hC000000000000000;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h40200000100000E0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"124027\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h3FAFFBFFFFFFFDFF;
-    z = 64'hBFF0000000010800;
-    ans = 64'hBFF0000000010800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"124641\n");
-    end
-    x = 64'hBFAFFFFF000007FE;
-    y = 64'hC000000000000001;
-    z = 64'hA698FCFB6D85D749;
-    ans = 64'h3FBFFFFF00000800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"125255\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hBFE0003FBFFFFFFF;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"125869\n");
-    end
-    x = 64'hC0002000000001FE;
-    y = 64'h40144398EEDB1AB3;
-    z = 64'hA070000008000003;
-    ans = 64'hC0246C2020B8D36E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"126483\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hC010000000000000;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"127097\n");
-    end
-    x = 64'h3816DC2B1E087754;
-    y = 64'h3F8FF807FFFFFFFF;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"127711\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hC010000000000001;
-    z = 64'hC7E65A23395745B0;
-    ans = 64'hC7E65A23395745B0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"128325\n");
-    end
-    x = 64'hBF7001FFFFFF7FFF;
-    y = 64'hC020000004000003;
-    z = 64'h3FC4ECED1B89DFEF;
-    ans = 64'h3FC8ED6D1C89DFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"128939\n");
-    end
-    x = 64'h400FDFFFFFFFFFBE;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'hC03BDFFFFFFFFFBC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"129553\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h41D0FC9ED7065B94;
-    z = 64'h3CAFEFFFFFFF0000;
-    ans = 64'h3CAFEFFFFFFF0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"130167\n");
-    end
-    x = 64'h43AFFFFFC0007FFE;
-    y = 64'hC340000000000000;
-    z = 64'h3FBFFFFBFFFFDFFE;
-    ans = 64'hC6FFFFFFC0007FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"130781\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'h41CF7FFFFEFFFFFE;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBCAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"131395\n");
-    end
-    x = 64'h43FFFFFFFFFFFFFE;
-    y = 64'hBFD0001FF7FFFFFE;
-    z = 64'h3F4007FFFFFFFFF7;
-    ans = 64'hC3E0001FF7FFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"132009\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"132623\n");
-    end
-    x = 64'hB81FFFFFC000007F;
-    y = 64'h43DFFFFEFF7FFFFF;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"133237\n");
-    end
-    x = 64'h0000000000000001;
-    y = 64'hFFE0000000000000;
-    z = 64'h40D4000040000000;
-    ans = 64'h40D4000040000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"133851\n");
-    end
-    x = 64'h400AD4AEE5D49F38;
-    y = 64'hC1E8D952BE2C6406;
-    z = 64'h3FB11FFFFFFFFFFE;
-    ans = 64'hC204D5BACED9ABF5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"134465\n");
-    end
-    x = 64'hC3F21524BE4E3979;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h4000000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"135079\n");
+    	$fwrite(fp,"94247\n");
     end
-    x = 64'h0000000000000001;
-    y = 64'hC34FFFFFFFFFFE00;
-    z = 64'hC00C0000000001FF;
-    ans = 64'hC00C0000000001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC03FFFF7FEFFFFFF;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFCF0003FFFFFFFE;
+    ans = 64'hC07003DBFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"135693\n");
+    	$fwrite(fp,"94553\n");
     end
-    x = 64'hD17FFFFFFFFFFFF0;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h4010000000002FFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC1D00003FFFFEFFF;
+    ReadData3E = 64'h380CDB22F03FB3C7;
+    ans = 64'h380CDB22F03FB3C7;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"136307\n");
+    	$fwrite(fp,"94859\n");
     end
-    x = 64'h0000000000000001;
-    y = 64'h41D0FFFF00000000;
-    z = 64'hBCA0000000000000;
-    ans = 64'hBCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBCAE007FFFFFFFFE;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hC000000000000003;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"136921\n");
+    	$fwrite(fp,"95165\n");
     end
-    x = 64'h3FF000000000200F;
-    y = 64'h41CFFFFFFC000000;
-    z = 64'h3FF000002000000F;
-    ans = 64'h41CFFFFFFC80401F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0027CED0481828DA;
+    ReadData2E = 64'hC018000000008000;
+    ReadData3E = 64'h408FFF7FFFF7FFFF;
+    ans = 64'h408FFF7FFFF7FFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"137535\n");
+    	$fwrite(fp,"95471\n");
     end
-    x = 64'h0000000000000001;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h3FD0000000000000;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'h427FFFFDFFFFFFFA;
+    ans = 64'h427FFFFDFFFFFFFA;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"138149\n");
+    	$fwrite(fp,"95777\n");
     end
-    x = 64'h4341FFFFFFFFFEFF;
-    y = 64'hBF748BF93240CAB0;
-    z = 64'hFFE0000000000001;
+    ReadData1E = 64'hCC1FFFFFDFFFFDFE;
+    ReadData2E = 64'hC0001FFFFFBFFFFF;
+    ReadData3E = 64'hFFE0000000000001;
     ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"138763\n");
+    	$fwrite(fp,"96083\n");
     end
-    x = 64'h0000000000000001;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hB8B000003F800000;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h400FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"139377\n");
+    	$fwrite(fp,"96389\n");
     end
-    x = 64'hC17201583A2EF803;
-    y = 64'h40085B90C3F3027B;
-    z = 64'hBE4153CE82AFC214;
-    ans = 64'hC18B690EE5AD454B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3F8B26434DA23461;
+    ReadData2E = 64'h48A46669B857A915;
+    ReadData3E = 64'h483000FFBFFFFFFE;
+    ans = 64'h48494F4D99000EF8;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"139991\n");
+    	$fwrite(fp,"96695\n");
     end
-    x = 64'hC3E401FFFFFFFFFF;
-    y = 64'h0000000000000001;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h402FEFFFFFFDFFFF;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h0020000000000007;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"140605\n");
+    	$fwrite(fp,"97001\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hBFBFFDFFC0000000;
-    z = 64'h380000400FFFFFFE;
-    ans = 64'h380000400FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h406FFF7FFFFFFFEF;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h75801FFBFFFFFFFF;
+    ans = 64'h75801FFBFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"141219\n");
+    	$fwrite(fp,"97307\n");
     end
-    x = 64'h8E20000000000007;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h434FFFFFD7FFFFFF;
-    ans = 64'h434FFFFFD7FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hFFF0000000080004;
+    ReadData3E = 64'h7FFFFFFFFFFEDFFF;
+    ans = 64'h7FFFFFFFFFFEDFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"141833\n");
+    	$fwrite(fp,"97613\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hB42F7FFFFFFFFE00;
-    z = 64'h8010000000000001;
-    ans = 64'h8010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h47FFFFFFFFFFC400;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h4B5FFFFFFFFFC3FE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"142447\n");
+    	$fwrite(fp,"97919\n");
     end
-    x = 64'h4050000000002080;
-    y = 64'hC08FFFEFFFF00000;
-    z = 64'h4800200000000000;
-    ans = 64'h4800200000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h39D000007FFFFFEF;
+    ReadData2E = 64'hC19A30C8DE8EA4F0;
+    ReadData3E = 64'hC3FFF24324316780;
+    ans = 64'hC3FFF24324316780;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"143061\n");
+    	$fwrite(fp,"98225\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h0010000000000001;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3CA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'h57E00000001FFFBF;
+    ans = 64'h57E00000001FFFBF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"143675\n");
+    	$fwrite(fp,"98531\n");
     end
-    x = 64'h3FDFFFFFFFEFFFFD;
-    y = 64'hC1F0000005FFFFFF;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC35000002000000B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"144289\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h400000000003FE00;
-    ans = 64'h400000000003FE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"144903\n");
-    end
-    x = 64'h405773C1B923E530;
-    y = 64'h3FD0512CFDE7267D;
-    z = 64'hBF87997BF553F060;
-    ans = 64'h4037E7CA80DC7473;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"145517\n");
-    end
-    x = 64'hC1EFFFFFFF803FFE;
-    y = 64'h3CA0000000000000;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFF00000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"146131\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hC0AFFFFFFF80003F;
-    z = 64'hBACFFFFF7FFFEFFE;
-    ans = 64'hBACFFFFF7FFFEFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"146745\n");
-    end
-    x = 64'h3FBFFDFFFFFFF800;
-    y = 64'h3CA0000000000001;
-    z = 64'h44AC4F8E8F747CBE;
-    ans = 64'h44AC4F8E8F747CBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"147359\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h3FCFFC007FFFFFFF;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h800C007FEFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"147973\n");
-    end
-    x = 64'hC1C00008FFFFFFFF;
-    y = 64'h33E200000007FFFE;
-    z = 64'hFFA2FFFFFFFFFFFF;
-    ans = 64'hFFA2FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"148587\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h3FD0000000000000;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h0021FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"149201\n");
-    end
-    x = 64'h3FEFFEFFFEFFFFFF;
-    y = 64'h3F1800000003FFFE;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFE800C000BA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"149815\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h3FD0000000000001;
-    z = 64'h41FEFFFFFFFFFBFF;
-    ans = 64'h41FEFFFFFFFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"150429\n");
-    end
-    x = 64'h43F003FFFFE00000;
-    y = 64'h3FC03FFFFFFFBFFF;
-    z = 64'h3F100FFFFFFFFFFF;
-    ans = 64'h43C0440FFFDF3FEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"151043\n");
-    end
-    x = 64'h80000FFFFFBFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"151657\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h3FF46233694EE7EA;
-    z = 64'hC1F00002000003FF;
-    ans = 64'hC1F00002000003FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"152271\n");
-    end
-    x = 64'h4F8FFFFFFFF9FFFF;
-    y = 64'h3FE0000000000000;
-    z = 64'h403DF104F345A123;
-    ans = 64'h4F7FFFFFFFF9FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"152885\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h4280008003FFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"153499\n");
-    end
-    x = 64'hB77FFFBFFFFFFFF6;
-    y = 64'hAD73FFFFE0000000;
-    z = 64'h800702E5BA613332;
-    ans = 64'h2503FFD7E0003FFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"154113\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h001FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"154727\n");
-    end
-    x = 64'h7FE0000000021FFF;
-    y = 64'h3C5FFFFFDFFF0000;
-    z = 64'hC010000000000000;
-    ans = 64'h7C4FFFFFE0033FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"155341\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h3FF0000000000000;
-    z = 64'hC3DFFBFFFFEFFFFF;
-    ans = 64'hC3DFFBFFFFEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"155955\n");
-    end
-    x = 64'h002EDA7062F2B653;
-    y = 64'hBF48C2B69C3CC227;
-    z = 64'hC01FFFFFFFFFFF82;
-    ans = 64'hC01FFFFFFFFFFF82;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"156569\n");
-    end
-    x = 64'h686FFFFFF8000200;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h3FD0000000000000;
-    ans = 64'h687FFFFFF80001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"157183\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hBF4FFFFBFFFFFFFC;
-    z = 64'hBFF03E0000000000;
-    ans = 64'hBFF03E0000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"157797\n");
-    end
-    x = 64'h38019EFBBA34957E;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h41F55F86DA17B5B8;
-    ans = 64'h41F55F86DA17B5B8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"158411\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h3FF0000001000004;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"159025\n");
-    end
-    x = 64'h40103FFFFFFFFFFD;
-    y = 64'h3FF000000001E000;
-    z = 64'h43C6885C3576B55B;
-    ans = 64'h43C6885C3576B55B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"159639\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h0000000000000000;
-    ans = 64'h002FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"160253\n");
-    end
-    x = 64'hC3E0000000001010;
-    y = 64'h402FFFFBFF7FFFFF;
-    z = 64'hC000000000000001;
-    ans = 64'hC41FFFFBFF80201F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"160867\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hBF2EFFFFDFFFFFFF;
-    ans = 64'hBF2EFFFFDFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"161481\n");
-    end
-    x = 64'hC06D269E93678E74;
-    y = 64'hC01FC2BEABDEFDBD;
-    z = 64'hC3C0001000FFFFFF;
-    ans = 64'hC3C0001000FFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"162095\n");
-    end
-    x = 64'hF41FFFE00000007F;
-    y = 64'h4010000000000001;
-    z = 64'h3CA0000000000001;
-    ans = 64'hF43FFFE000000081;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"162709\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hBFF057662D37995D;
-    z = 64'hC1CFFFFFFFFFFFC2;
-    ans = 64'hC1CFFFFFFFFFFFC2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"163323\n");
-    end
-    x = 64'h3817B6E353940A3E;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h3FAFFFFFFFF83FFF;
-    ans = 64'h3FAFFFFFFFF83FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"163937\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h3BE001FFFFFFEFFF;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"164551\n");
-    end
-    x = 64'hC0D00000403FFFFF;
-    y = 64'h80204CCA9259A411;
-    z = 64'h5B900000203FFFFF;
-    ans = 64'h5B900000203FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"165165\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h4340000000000000;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"165779\n");
-    end
-    x = 64'h41C29C47332872B1;
-    y = 64'h381FFFFF81FFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"166393\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hB7E7FFFFFFFDFFFF;
-    ans = 64'hB7E7FFFFFFFDFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"167007\n");
-    end
-    x = 64'h3812BA3824E4D9E0;
-    y = 64'hC00FFFFFFFEFFFFE;
-    z = 64'h3F493F24CFFC16BF;
-    ans = 64'h3F493F24CFFC16BF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"167621\n");
-    end
-    x = 64'hC1CFFFFFFFFFFF7F;
-    y = 64'h7FE0000000000000;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"168235\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h7FFFFEFFFFFF8000;
-    z = 64'h43EFFFFF7FFFFFFE;
-    ans = 64'h7FFFFEFFFFFF8000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"168849\n");
-    end
-    x = 64'hC3C523B80855F196;
-    y = 64'h7FE0000000000001;
-    z = 64'h400FFFEEFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"169463\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h3D600FFF7FFFFFFF;
-    z = 64'h434FFFFFFFFFFFFF;
+    ReadData1E = 64'h800890D34C5F8261;
+    ReadData2E = 64'h43EDFFFFFFFFFBFE;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
     ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"170077\n");
+    	$fwrite(fp,"98837\n");
     end
-    x = 64'h38B0000000041000;
-    y = 64'h41D0FAA3D73DCB12;
-    z = 64'h41FFFF7FBFFFFFFF;
-    ans = 64'h41FFFF7FBFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hBFFFFFFFFFFFFFFC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"170691\n");
+    	$fwrite(fp,"99143\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hA38000FFFFF7FFFF;
+    ReadData2E = 64'hB7F8000003FFFFFF;
+    ReadData3E = 64'hBFDFF000000001FE;
+    ans = 64'hBFDFF000000001FE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"171305\n");
+    	$fwrite(fp,"99449\n");
     end
-    x = 64'hC00FFFFFFF7FFDFF;
-    y = 64'h41DFEFF800000000;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hC1FFEFF7FF903E20;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC1316F6AD91EBB89;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h8010000000116F69;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"171919\n");
+    	$fwrite(fp,"99755\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h7FF0000000000001;
-    z = 64'h7FE5A216D1F18F5C;
+    ReadData1E = 64'hB7FFFF9FFFFFFFFF;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'hBBC0800000001FFF;
+    ans = 64'hF7EFFFA000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"100061\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h41DFFF01FFFFFFFF;
+    ReadData3E = 64'hBCA1790765D39159;
+    ans = 64'hBCA1790765D39159;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"100367\n");
+    end
+    ReadData1E = 64'h47FF7FFFEFFFFFFF;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"100673\n");
+    end
+    ReadData1E = 64'h47F0007FFFFFFFFB;
+    ReadData2E = 64'h7FD000007FFDFFFF;
+    ReadData3E = 64'h41CFFFF00003FFFF;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"100979\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h4010004000100000;
+    ans = 64'h4010004000100001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"101285\n");
+    end
+    ReadData1E = 64'h3F2FFFBFFFFC0000;
+    ReadData2E = 64'hBA446C0F1185D142;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hC01FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"101591\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"101897\n");
+    end
+    ReadData1E = 64'h40302007FFFFFFFE;
+    ReadData2E = 64'h401BF920C8395318;
+    ReadData3E = 64'h2C1FFFEFFFFEFFFE;
+    ans = 64'h405C3121065A29D7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"102203\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC3CFBF7FFFFFFFFF;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'h80AFBF7FFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"102509\n");
+    end
+    ReadData1E = 64'h4010000020000040;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'hC5100000010000FF;
     ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"172533\n");
+    	$fwrite(fp,"102815\n");
     end
-    x = 64'hBF54477471BBE4DC;
-    y = 64'h4A3DFFFFFFFFFFFC;
-    z = 64'hC1DFFFFFE03FFFFF;
-    ans = 64'hC9A302FD2AA0268C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h7FEF800002000000;
+    ReadData3E = 64'h41C020001FFFFFFF;
+    ans = 64'h41C020001FFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"173147\n");
+    	$fwrite(fp,"103121\n");
     end
-    x = 64'h33EFFFFFEFFFBFFF;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC226A456871BA660;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"173761\n");
+    	$fwrite(fp,"103427\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hBFDBFFFFFFEFFFFE;
-    z = 64'hC00FFFFFFC040000;
-    ans = 64'hC00FFFFFFC040000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hA8FA294A615C92B1;
+    ReadData2E = 64'hC0080000003FFFFF;
+    ReadData3E = 64'hC000007FFFFFFEFF;
+    ans = 64'hC000007FFFFFFEFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"174375\n");
+    	$fwrite(fp,"103733\n");
     end
-    x = 64'h3FBFFFFFF8000200;
-    y = 64'h8000000000000000;
-    z = 64'hB802E70A9756F601;
-    ans = 64'hB802E70A9756F601;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hC7EFFFFF80FFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"174989\n");
+    	$fwrite(fp,"104039\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hBCD9BB552B097DCA;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"175603\n");
-    end
-    x = 64'h3FFFFFE000FFFFFF;
-    y = 64'hBFBFFEFFFFFFFFFB;
-    z = 64'h380A0D5AA19EAA71;
-    ans = 64'hBFCFFEE001FFF7FA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"176217\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"176831\n");
-    end
-    x = 64'hFFDC0000FFFFFFFF;
-    y = 64'hFDFFFFFFFFFFF801;
-    z = 64'hBFE0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"177445\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h8010000000000000;
-    z = 64'h402FFFFFFF800100;
-    ans = 64'h402FFFFFFF800100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"178059\n");
-    end
-    x = 64'h3D900EFFFFFFFFFF;
-    y = 64'hC36C60E0A6FAA0B9;
-    z = 64'h251FC7AE5368B48E;
-    ans = 64'hC10C7B7B79972BAE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"178673\n");
-    end
-    x = 64'h41FFEFFFFFFFFDFE;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h0000000000000000;
-    ans = 64'h822FEFFFFFFFFDFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"179287\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hC0E000000001FFFD;
-    z = 64'hC1CFFFFFF0007FFF;
-    ans = 64'hC1CFFFFFF0007FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"179901\n");
-    end
-    x = 64'hB7E0010000007FFF;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hDE4FFFDFFFFF7FFE;
-    ans = 64'hDE4FFFDFFFFF7FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"180515\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h43480AE532861422;
-    z = 64'h4010000000000000;
+    ReadData1E = 64'hB7E0800001000000;
+    ReadData2E = 64'hB9240000003FFFFE;
+    ReadData3E = 64'h4010000000000000;
     ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"181129\n");
+    	$fwrite(fp,"104345\n");
     end
-    x = 64'h407EBFEA5ED3E8F1;
-    y = 64'h43DBEA5EAAF280D9;
-    z = 64'hC3C93A8974B023EF;
-    ans = 64'h446ACCD5778018ED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"181743\n");
+    	$fwrite(fp,"104651\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hBCA0000000000001;
-    z = 64'hC340000000000000;
+    ReadData1E = 64'hB80F000000000008;
+    ReadData2E = 64'h3AF0407FFFFFFFFF;
+    ReadData3E = 64'h3FE1FC3C8689A584;
+    ans = 64'h3FE1FC3C8689A584;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"104957\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h80169DE23509F708;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"105263\n");
+    end
+    ReadData1E = 64'h43EF7FFFFFFFF7FE;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'h7FFFFFFFFFEF0000;
+    ans = 64'h7FFFFFFFFFEF0000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"105569\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h402FFFFFFFEFFFF8;
+    ReadData3E = 64'h43D42686CD65475F;
+    ans = 64'h43D42686CD65475F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"105875\n");
+    end
+    ReadData1E = 64'hC04FFFFFFFFC7FFF;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hBCAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"106181\n");
+    end
+    ReadData1E = 64'hB7E00080000001FF;
+    ReadData2E = 64'h41F07FFFFFFFFFFE;
+    ReadData3E = 64'h3FF6DBA784E8283D;
+    ans = 64'h3FF6DBA784E8283D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"106487\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'h7FFFF3FFFFFFFFFE;
+    ans = 64'h7FFFF3FFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"106793\n");
+    end
+    ReadData1E = 64'hB800007FFDFFFFFE;
+    ReadData2E = 64'h3FC0E7ABB4FEA446;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"107099\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h3FDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"107405\n");
+    end
+    ReadData1E = 64'hBFF15CA7EE372F75;
+    ReadData2E = 64'hC1FFFFFFFFFFBFBF;
+    ReadData3E = 64'hC0BFFFFE001FFFFF;
+    ans = 64'h42015CA6EE371C97;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"107711\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBE00000FFFFFFFBF;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"108017\n");
+    end
+    ReadData1E = 64'hBFD0E4DFE770D252;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'h8DC0000001FFFEFE;
+    ans = 64'h8DC0000001FFFEFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"108323\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3E500200FFFFFFFF;
+    ReadData3E = 64'hC1D0003FFFFFFEFE;
+    ans = 64'hC1D0003FFFFFFEFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"108629\n");
+    end
+    ReadData1E = 64'hBFD03FFFFBFFFFFE;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h3CA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"108935\n");
+    end
+    ReadData1E = 64'hB810011FFFFFFFFF;
+    ReadData2E = 64'h3CAFFFFFF7FFFFFC;
+    ReadData3E = 64'h41DFFFFDFFFFBFFE;
+    ans = 64'h41DFFFFDFFFFBFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"109241\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'h40008000003FFFFF;
+    ans = 64'h40008000003FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"109547\n");
+    end
+    ReadData1E = 64'hBFF0000000022000;
+    ReadData2E = 64'h42F63997A8DDC3FE;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'hC2F63997A8E0B784;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"109853\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hBCAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"110159\n");
+    end
+    ReadData1E = 64'hC3DE554489E9FBEB;
+    ReadData2E = 64'hB7FF8000000003FF;
+    ReadData3E = 64'h3FFF32CBAFD63CA0;
+    ans = 64'h3FFF32CBAFD63CA0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"110465\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h4C1FFC003FFFFFFE;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h434FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"110771\n");
+    end
+    ReadData1E = 64'hC80FFFF800000000;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'hC0098E4ADD5BCBCE;
+    ans = 64'hC0098E4ADD5BCBCE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"111077\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h43DFFFF7FFC00000;
+    ReadData3E = 64'hFFE00000000003DF;
+    ans = 64'hFFE00000000003DF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"111383\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFC07FF;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'hB95FFFFFFFFC07FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"111689\n");
+    end
+    ReadData1E = 64'hC15FFFF5FFFFFFFE;
+    ReadData2E = 64'hC02DFFFFFFFFFFBF;
+    ReadData3E = 64'h41D08607E1470F0C;
+    ans = 64'h41D266074B470F08;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"111995\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'h41C386E10783B27B;
+    ans = 64'h41C386E10783B27B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"112301\n");
+    end
+    ReadData1E = 64'hFFFB45BA74ABDCC5;
+    ReadData2E = 64'h0004C737D93533CD;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hFFFB45BA74ABDCC5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"112607\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h3CA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"112913\n");
+    end
+    ReadData1E = 64'h3FC7FFFFFFE00000;
+    ReadData2E = 64'hBF7FBFFFFFFFFFFF;
+    ReadData3E = 64'h37EFFFFE000FFFFF;
+    ans = 64'hBF57CFFFFFE03FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"113219\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC03BFFFFFFFFFFF0;
+    ReadData3E = 64'hC340000000000000;
     ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"182357\n");
+    	$fwrite(fp,"113525\n");
     end
-    x = 64'h48080001FFFFFFFE;
-    y = 64'h40E00000011FFFFF;
-    z = 64'hBFD0000000000001;
-    ans = 64'h48F8000201B00020;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC02528035E1CC78A;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'h00000000FFFFBFFF;
+    ans = 64'h3CE528035E1CC789;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"182971\n");
+    	$fwrite(fp,"113831\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hB7F0E863BB89B480;
-    ans = 64'hB7F0E863BB89B480;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h40100000000003BF;
+    ReadData3E = 64'h4800000001FFFFFC;
+    ans = 64'h4800000001FFFFFC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"183585\n");
+    	$fwrite(fp,"114137\n");
     end
-    x = 64'h43D968AFF70E5E0C;
-    y = 64'h7D3000800000001F;
-    z = 64'hC3CDFFFFFFEFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h40C00003FFFEFFFE;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'hC0A00003FFFEFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"184199\n");
+    	$fwrite(fp,"114443\n");
     end
-    x = 64'hC1AE5B70CEBC30DD;
-    y = 64'hBFD0000000000000;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3815F31AA300BAC5;
+    ReadData2E = 64'h00282D6384BE04FD;
+    ReadData3E = 64'h40A10711683D5DEF;
+    ans = 64'h40A10711683D5DEF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"184813\n");
+    	$fwrite(fp,"114749\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h40355F1CE077AB6A;
-    z = 64'h43F00000103FFFFF;
-    ans = 64'h43F00000103FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'hB7E0000000000202;
+    ans = 64'hB7E0000000000202;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"185427\n");
+    	$fwrite(fp,"115055\n");
     end
-    x = 64'h001FF80000100000;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h394000000040001E;
-    ans = 64'h394000000040001E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBBCFFFFFFFFBFFFA;
+    ReadData2E = 64'h95C71697A05241D8;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h3FE0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"186041\n");
+    	$fwrite(fp,"115361\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hC01F7FFFFFFFFFFE;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h8010000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"186655\n");
+    	$fwrite(fp,"115667\n");
     end
-    x = 64'hFFDFFFFFFFFBBFFF;
-    y = 64'h7FEF000000000200;
-    z = 64'h400FF8000007FFFF;
+    ReadData1E = 64'h3FC6AF6973D6EEE0;
+    ReadData2E = 64'h81DFFFF000007FFF;
+    ReadData3E = 64'hC02FFFFFBBFFFFFE;
+    ans = 64'hC02FFFFFBBFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"115973\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h4060003C00000000;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h4010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"116279\n");
+    end
+    ReadData1E = 64'hBFF0000000011FFE;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'hA04FFFFFFFFFEFF6;
+    ans = 64'h3FE0000000011FFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"116585\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h9550001FFFFFFFFF;
+    ReadData3E = 64'hBFE8C4D9D2CF8887;
+    ans = 64'hBFE8C4D9D2CF8887;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"116891\n");
+    end
+    ReadData1E = 64'h3FB001FFFFFBFFFF;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"117197\n");
+    end
+    ReadData1E = 64'hBDC941E1BC02969D;
+    ReadData2E = 64'h3F5C6E5429567A7D;
+    ReadData3E = 64'h7FF000000002003F;
+    ans = 64'h7FF800000002003F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"117503\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'h3D63D5CA425674DB;
+    ans = 64'h3D63D5CA425674DB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"117809\n");
+    end
+    ReadData1E = 64'hB80C7A2531F5CBA2;
+    ReadData2E = 64'hB7F00000000040FF;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hBFD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"118115\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h000FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"118421\n");
+    end
+    ReadData1E = 64'h880FFFFFCFFFFFFE;
+    ReadData2E = 64'h2D700000001FFFDE;
+    ReadData3E = 64'hBCAFFC000007FFFF;
+    ans = 64'hBCAFFC000007FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"118727\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC3E00007FFFFFDFF;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hC00FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"119033\n");
+    end
+    ReadData1E = 64'hC031DFFFFFFFFFFE;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h429000000007FFFA;
+    ans = 64'h429000000008477A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"119339\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h41C0000000FDFFFF;
+    ReadData3E = 64'h3FDFFC0000000002;
+    ans = 64'h3FDFFC0000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"119645\n");
+    end
+    ReadData1E = 64'hC010000008100000;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hFFF0000000000000;
     ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"187269\n");
+    	$fwrite(fp,"119951\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hBFE0000000000000;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBE67FFFF7FFFFFFF;
+    ReadData2E = 64'hC3FFFFFE003FFFFF;
+    ReadData3E = 64'h3E1FFFE003FFFFFE;
+    ans = 64'h4277FFFE003007FD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"120257\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h403FFFEFFFF80000;
+    ans = 64'h403FFFEFFFF80000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"120563\n");
+    end
+    ReadData1E = 64'hBFF55E36003CB592;
+    ReadData2E = 64'h4913B02D75F6CF08;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'hC91A4B2928CD1BF3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"120869\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"121175\n");
+    end
+    ReadData1E = 64'hBF8FFFFFFFFFE01F;
+    ReadData2E = 64'h43D000000000000B;
+    ReadData3E = 64'h3FBF800FFFFFFFFE;
+    ans = 64'hC36FFFFFFFFFE035;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"121481\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC01FFFFDFFFFDFFF;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"121787\n");
+    end
+    ReadData1E = 64'hBFAFEFFFFFEFFFFE;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'h3FDFFFFFFDFFF000;
+    ans = 64'h3FE1FEFFFEFEF800;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"122093\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3F4001FFFFFFFFDF;
+    ReadData3E = 64'hB7EFFFFFFF6FFFFF;
+    ans = 64'hB7EFFFFFFF6FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"122399\n");
+    end
+    ReadData1E = 64'hC02047FFFFFFFFFF;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"122705\n");
+    end
+    ReadData1E = 64'h239000003FDFFFFF;
+    ReadData2E = 64'hC69003FFFFFBFFFF;
+    ReadData3E = 64'hC80FDFFFFFF80000;
+    ans = 64'hC80FDFFFFFF80000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"123011\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h401FF00000000000;
+    ans = 64'h401FF00000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"123317\n");
+    end
+    ReadData1E = 64'h5A3FFFFFFF7FFF80;
+    ReadData2E = 64'h41D000007BFFFFFF;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'h5C2000007BBFFFBD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"123623\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"123929\n");
+    end
+    ReadData1E = 64'hA3BFFFFFFEC00000;
+    ReadData2E = 64'hFFFFFFFFFFFFFFAE;
+    ReadData3E = 64'hC010000004080000;
+    ans = 64'hFFFFFFFFFFFFFFAE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"124235\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h43E000003FFFFFFC;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"124541\n");
+    end
+    ReadData1E = 64'hBFE2ABEEC977610C;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'hA42FFF8FFFFFFFFE;
+    ans = 64'h3FF2ABEEC977610D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"124847\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3FB00FFF00000000;
+    ReadData3E = 64'hC1C0000000000000;
+    ans = 64'hC1C0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"125153\n");
+    end
+    ReadData1E = 64'h3F599261FF10D874;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"125459\n");
+    end
+    ReadData1E = 64'h4010000002000002;
+    ReadData2E = 64'hB7EAC9B31C37E360;
+    ReadData3E = 64'h401FFFFC07FFFFFE;
+    ans = 64'h401FFFFC07FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"125765\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'hB18A7754689D82F3;
+    ans = 64'hB18A7754689D82F3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"126071\n");
+    end
+    ReadData1E = 64'h381FFFFDFFFBFFFF;
+    ReadData2E = 64'hC02F9C2590DFA192;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'hB85F9C23971954FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"126377\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"126683\n");
+    end
+    ReadData1E = 64'hC050001000000FFF;
+    ReadData2E = 64'h30CFFFFF807FFFFF;
+    ReadData3E = 64'h41F431202C87A685;
+    ans = 64'h41F431202C87A685;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"126989\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC061000080000000;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h3FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"127295\n");
+    end
+    ReadData1E = 64'h401FFFFFFDFBFFFE;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'hC0200000200003FF;
+    ans = 64'hC044000006FE00FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"127601\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h40C0000008000000;
+    ReadData3E = 64'h800004001FFFFFFE;
+    ans = 64'h800004001FFFDFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"127907\n");
+    end
+    ReadData1E = 64'h306000000003FBFF;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h401FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"128213\n");
+    end
+    ReadData1E = 64'h410FFEFFFFF7FFFF;
+    ReadData2E = 64'hB0BA68A8F1E0C6BE;
+    ReadData3E = 64'h0021FFFFFFFFBFFF;
+    ans = 64'hB1DA67D5AC929D8D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"128519\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'h4BB00020001FFFFF;
+    ans = 64'h4BB00020001FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"128825\n");
+    end
+    ReadData1E = 64'h3FC100000FFFFFFF;
+    ReadData2E = 64'h400FFFFFEFFFEFFF;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h3FE10000077FF776;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"129131\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"129437\n");
+    end
+    ReadData1E = 64'hC80000000037FFFF;
+    ReadData2E = 64'hBF400003FFFFFFC0;
+    ReadData3E = 64'h3FC00001001FFFFF;
+    ans = 64'h475000040037FFCD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"129743\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3FCEBFFFFFFFFFFF;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"130049\n");
+    end
+    ReadData1E = 64'h3F5FFFEFFFFF7FFF;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'hBCA0000000000020;
+    ans = 64'hC2AFFFEFFFFF7FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"130355\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBFEE6A55223FE187;
+    ReadData3E = 64'h40BF2A4F0D6A99C1;
+    ans = 64'h40BF2A4F0D6A99C1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"130661\n");
+    end
+    ReadData1E = 64'h41DFFFE00FFFFFFF;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC52FFFE00FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"130967\n");
+    end
+    ReadData1E = 64'h409F8000003FFFFF;
+    ReadData2E = 64'h3B6FEFFFFFFFFFFD;
+    ReadData3E = 64'hC01001FFEFFFFFFF;
+    ans = 64'hC01001FFEFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"131273\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'h00290AEBB101790F;
+    ans = 64'h001215D76202F21C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"131579\n");
+    end
+    ReadData1E = 64'hB9F0000400001FFF;
+    ReadData2E = 64'h7FFFC7FFFFFFFFFF;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"131885\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h401FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"132191\n");
+    end
+    ReadData1E = 64'hBFA1000000000001;
+    ReadData2E = 64'h7FDFFFFE003FFFFF;
+    ReadData3E = 64'h7FD1000000007FFF;
+    ans = 64'h7FCFE00021FCBFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"132497\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hBF2FFF8020000000;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h3CAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"132803\n");
+    end
+    ReadData1E = 64'h3CFF8001FFFFFFFE;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'h9B5000000020003E;
+    ans = 64'hC05F8001FFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"133109\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h3FC5695F385872B9;
+    ReadData3E = 64'hBFEFFFFFFFFFFFE7;
+    ans = 64'hBFEFFFFFFFFFFFE7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"133415\n");
+    end
+    ReadData1E = 64'hC1CFFFFFDFFFFFE0;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"133721\n");
+    end
+    ReadData1E = 64'h380C785BDC80505F;
+    ReadData2E = 64'h401004000000007E;
+    ReadData3E = 64'hBFC8A5BBE8CA87F4;
+    ans = 64'hBFC8A5BBE8CA87F4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"134027\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hBFEEB93FEB6D9A27;
+    ans = 64'hBFEEB93FEB6D9A2B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"134333\n");
+    end
+    ReadData1E = 64'hBE7000023FFFFFFF;
+    ReadData2E = 64'hC69FBF7FFFFFFFFF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"134639\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"134945\n");
+    end
+    ReadData1E = 64'h413000003FE00000;
+    ReadData2E = 64'h4047D41D01C7BC9B;
+    ReadData3E = 64'hC7EFEFFFFFFFDFFF;
+    ans = 64'hC7EFEFFFFFFFDFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"135251\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h8010BFFFFFFFFFFF;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hBCA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"135557\n");
+    end
+    ReadData1E = 64'hC1861137DB5A3CE3;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hC7F04B353236C72C;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"135863\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h402FFFFFFF000040;
+    ReadData3E = 64'h47EAAF592AC502DE;
+    ans = 64'h47EAAF592AC502DE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"136169\n");
+    end
+    ReadData1E = 64'h434FFFC07FFFFFFE;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"136475\n");
+    end
+    ReadData1E = 64'hB9F94E1DAE778706;
+    ReadData2E = 64'hB270000000000006;
+    ReadData3E = 64'h381FC0000000FFFE;
+    ans = 64'h381FC0000000FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"136781\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'h3F1A7E5B60253554;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"137087\n");
+    end
+    ReadData1E = 64'h404B476C9FC42AB2;
+    ReadData2E = 64'h35CF000003FFFFFE;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"137393\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"137699\n");
+    end
+    ReadData1E = 64'h40303FFFFFFFFEFF;
+    ReadData2E = 64'h389000003FFF0000;
+    ReadData3E = 64'hBFE000003FFEFFFE;
+    ans = 64'hBFE000003FFEFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"138005\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h400FFFFFFFFF3FFF;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h0010000000000005;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"138311\n");
+    end
+    ReadData1E = 64'h297FC000FFFFFFFE;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBD6BDC398D105938;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"138617\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'h7FDFFBFFFFFFFEFF;
+    ReadData3E = 64'h381E1EE6EF921ABD;
+    ans = 64'h3CBFFBFFFFFFFEFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"138923\n");
+    end
+    ReadData1E = 64'h735FFFF8007FFFFF;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"139229\n");
+    end
+    ReadData1E = 64'hC030000000000FE0;
+    ReadData2E = 64'h0DDFFFFB00000000;
+    ReadData3E = 64'h3CA0000000002400;
+    ans = 64'h3CA0000000002400;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"139535\n");
+    end
+    ReadData1E = 64'h0000000000000001;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h43FDC6998218B001;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"139841\n");
+    end
+    ReadData1E = 64'h476FF80000020000;
+    ReadData2E = 64'hC03000001FFBFFFE;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'hC7AFF8003FEA01FC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"140147\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hBFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"140453\n");
+    end
+    ReadData1E = 64'hC01FFFF000000001;
+    ReadData2E = 64'hC0116F956B466478;
+    ReadData3E = 64'hC00FFFFFFF7FFFFC;
+    ans = 64'h403EDF1967075DAB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"140759\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC3EFFFFFFE03FFFE;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'h840FFFFFFE03FFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"141065\n");
+    end
+    ReadData1E = 64'hC005937FE4462628;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'hC24FF9FFFFFFFFFE;
+    ans = 64'hC24FF9FFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"141371\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC1EFFFBFFFFFFFFB;
+    ReadData3E = 64'hC3566C56029D4B3B;
+    ans = 64'hC3566C56029D4B3B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"141677\n");
+    end
+    ReadData1E = 64'h43CFF807FFFFFFFF;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hBFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"141983\n");
+    end
+    ReadData1E = 64'h381FFF83FFFFFFFF;
+    ReadData2E = 64'hA0AC00000007FFFF;
+    ReadData3E = 64'hB80F77FFFFFFFFFE;
+    ans = 64'hB80F77FFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"142289\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h4072000000000002;
+    ans = 64'h4072000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"142595\n");
+    end
+    ReadData1E = 64'hBCAFFFEFFFFFE000;
+    ReadData2E = 64'h3FFFFFFEFFFFFF80;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"142901\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'h3FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"143207\n");
+    end
+    ReadData1E = 64'h00100000403FFFFF;
+    ReadData2E = 64'hC3D800000FFFFFFF;
+    ReadData3E = 64'hFFF77AAF6197A823;
+    ans = 64'hFFFF7AAF6197A823;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"143513\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h43D100000007FFFF;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"143819\n");
+    end
+    ReadData1E = 64'hC030000FFDFFFFFF;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'h3FEFC0000000003F;
+    ans = 64'h3FEFC0000000003F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"144125\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h1F2DEFFFFFFFFFFF;
+    ReadData3E = 64'hC34D4DD27012E241;
+    ans = 64'hC34D4DD27012E241;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"144431\n");
+    end
+    ReadData1E = 64'hB95FFFFFFF7FDFFE;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"144737\n");
+    end
+    ReadData1E = 64'h73B2AA12DD4A0E23;
+    ReadData2E = 64'hFFFFFFFFFFF6FFFF;
+    ReadData3E = 64'h480000000400007F;
+    ans = 64'hFFFFFFFFFFF6FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"145043\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFE020000000FFFF;
+    ans = 64'hFFE020000000FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"145349\n");
+    end
+    ReadData1E = 64'hC1F001000007FFFF;
+    ReadData2E = 64'h47F47FFFFFFFFFFF;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'hC9F48148000A3FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"145655\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hBFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"145961\n");
+    end
+    ReadData1E = 64'hC00007FFFFBFFFFF;
+    ReadData2E = 64'h40000000100001FE;
+    ReadData3E = 64'hC80FFFFFFFC00001;
+    ans = 64'hC80FFFFFFFC00001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"146267\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h4010000008400000;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"146573\n");
+    end
+    ReadData1E = 64'h3800000800001000;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'h3FFC0000003FFFFF;
+    ans = 64'h3FFC0000003FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"146879\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h613FFF7FFF7FFFFF;
+    ReadData3E = 64'hBE28B1A0E27593C1;
+    ans = 64'hBE28B1A0E27593C1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"147185\n");
+    end
+    ReadData1E = 64'h4800000000004001;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'h44B0000000004002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"147491\n");
+    end
+    ReadData1E = 64'h43EBF7FFFFFFFFFE;
+    ReadData2E = 64'h0010000007FFFFC0;
+    ReadData3E = 64'hC1D0007DFFFFFFFF;
+    ans = 64'hC1D0007DFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"147797\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFA8C76ADFD94B46;
+    ans = 64'hBFA8C76ADFD94B46;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"148103\n");
+    end
+    ReadData1E = 64'hB7F0000040000003;
+    ReadData2E = 64'h43CFCFFFFFFFFFFF;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hC000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"148409\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"148715\n");
+    end
+    ReadData1E = 64'h3EAB991333A4F989;
+    ReadData2E = 64'h7FF000001BFFFFFF;
+    ReadData3E = 64'hBF800001FFFFFFFE;
+    ans = 64'h7FF800001BFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"149021\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC8045EC85D798E1F;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"149327\n");
+    end
+    ReadData1E = 64'h9E40000800000007;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'h3FF000080000001F;
+    ans = 64'h3FF000080000001F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"149633\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC05F80001FFFFFFF;
+    ReadData3E = 64'hC7E0020000000040;
+    ans = 64'hC7E0020000000040;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"149939\n");
+    end
+    ReadData1E = 64'hD5E03FFFFFFFFFEF;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'hD5C03FFFFFFFFFF0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"150245\n");
+    end
+    ReadData1E = 64'hC3C000000003FFF6;
+    ReadData2E = 64'hC01FE01FFFFFFFFF;
+    ReadData3E = 64'h3FDFFFFFFEF7FFFF;
+    ans = 64'h43EFE0200007F7F3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"150551\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'hBFC4ED8EFAC28779;
+    ans = 64'hBFC4ED8EFAC28779;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"150857\n");
+    end
+    ReadData1E = 64'h48000010FFFFFFFE;
+    ReadData2E = 64'h4070020000003FFF;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h4880021102203FFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"151163\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hBCAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"151469\n");
+    end
+    ReadData1E = 64'h3EAFFFF800000010;
+    ReadData2E = 64'hC06466011810A25A;
+    ReadData3E = 64'h3FC00000000007FE;
+    ans = 64'h3FBFF5CD0200C7CE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"151775\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h41C000801FFFFFFF;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h434FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"152081\n");
+    end
+    ReadData1E = 64'hBFF0000000000010;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'h3F9FFF7FFFFFFFFA;
+    ans = 64'hBFDE00080000001E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"152387\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FF00000001000FE;
+    ReadData3E = 64'h7FFFFF0000400000;
+    ans = 64'h7FFFFF0000400000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"152693\n");
+    end
+    ReadData1E = 64'h3C4000000007FFFE;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h3C3000000007FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"152999\n");
+    end
+    ReadData1E = 64'h002FFF8000003FFE;
+    ReadData2E = 64'hC3F00000017FFFFF;
+    ReadData3E = 64'h41FFFFFFFFDFF800;
+    ans = 64'h41FFFFFFFFDFF800;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"153305\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'hC1E57FCF69CF5180;
+    ans = 64'hC1E57FCF69CF5180;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"153611\n");
+    end
+    ReadData1E = 64'hBDF00001FFFFFFFF;
+    ReadData2E = 64'h508FFFFBEFFFFFFE;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hCE8FFFFFEFFF7DFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"153917\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h0027FFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"154223\n");
+    end
+    ReadData1E = 64'h480000000103FFFE;
+    ReadData2E = 64'hFFFFEFFFC0000000;
+    ReadData3E = 64'hC1EFFFFFF8000100;
+    ans = 64'hFFFFEFFFC0000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"154529\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC1D0000000007FF7;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hC01FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"154835\n");
+    end
+    ReadData1E = 64'h408001FFFFFFE000;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hC01DFBFFFFFFFFFF;
+    ans = 64'h407F8C0FFFFFBFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"155141\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFBFFF7FFFFFE000;
+    ReadData3E = 64'hBE600000200000FE;
+    ans = 64'hBE600000200000FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"155447\n");
+    end
+    ReadData1E = 64'h40093E4AEFD3FCC6;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'h40093E4AEFD3FCC6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"155753\n");
+    end
+    ReadData1E = 64'hC3D1FE0000000000;
+    ReadData2E = 64'hC3D07FFFFDFFFFFF;
+    ReadData3E = 64'hFFDFFFFFFF00000F;
+    ans = 64'hFFDFFFFFFF00000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"156059\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'hC1FFFFFFFFDDFFFF;
+    ans = 64'hC1FFFFFFFFDDFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"156365\n");
+    end
+    ReadData1E = 64'hC3FFFFEFFFFC0000;
+    ReadData2E = 64'hA307FFFFFFBFFFFE;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h3FDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"156671\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h8000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"156977\n");
+    end
+    ReadData1E = 64'h4803C1CD4177B2BE;
+    ReadData2E = 64'hC80FFFFFFC200000;
+    ReadData3E = 64'hC7F0001FFFFFEFFE;
+    ans = 64'hD023C1CD3F133AE3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"157283\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FDFC00000FFFFFF;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4017F000003FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"157589\n");
+    end
+    ReadData1E = 64'hC04FFFFFCFFFFFFF;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h4024BEC7A4366D96;
+    ans = 64'hC05D6826DB79324B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"157895\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hB1100000200000FF;
+    ReadData3E = 64'h8024D4E33D003A28;
+    ans = 64'h8024D4E33D003A28;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"158201\n");
+    end
+    ReadData1E = 64'h41BFFFFFDFFFDFFF;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"158507\n");
+    end
+    ReadData1E = 64'h3FBF20EB2E06830F;
+    ReadData2E = 64'h47C7BB68F15E5DDB;
+    ReadData3E = 64'h46EFFFDFFFFFEFFE;
+    ans = 64'h479719F77931B106;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"158813\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'h615A2EE20A8610C4;
+    ans = 64'h615A2EE20A8610C4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"159119\n");
+    end
+    ReadData1E = 64'h3C7680720C59CAC2;
+    ReadData2E = 64'hBF80027FFFFFFFFE;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'hBFD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"159425\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'h0020000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"159731\n");
+    end
+    ReadData1E = 64'h979FF7FFFF000000;
+    ReadData2E = 64'hC00800007FFFFFFF;
+    ReadData3E = 64'hBF8FFFFFF8000006;
+    ans = 64'hBF8FFFFFF8000006;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"160037\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h3F6FFFFFFFFFFFFF;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"160343\n");
+    end
+    ReadData1E = 64'h36AD8E7E53A268EF;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFDD8B65DCF02CB0;
+    ans = 64'hBFDD8B65DCF02CB0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"160649\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h883C75A4B28F7EB9;
+    ReadData3E = 64'hC7E020000FFFFFFF;
+    ans = 64'hC7E020000FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"160955\n");
+    end
+    ReadData1E = 64'h43B003FFFFFEFFFF;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"161261\n");
+    end
+    ReadData1E = 64'h3FDFFE0000001FFF;
+    ReadData2E = 64'hC7EF000000000020;
+    ReadData3E = 64'h41DFFFFFFFFFBEFF;
+    ans = 64'hC7DEFE1000001F1F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"161567\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'h3F800008000007FE;
+    ans = 64'h3F800008000007FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"161873\n");
+    end
+    ReadData1E = 64'h4480001FFFFFFFEE;
+    ReadData2E = 64'h1A2FFFFFC00003FF;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'h3CA0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"162179\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"162485\n");
+    end
+    ReadData1E = 64'h7FFFBFFFFFFF7FFE;
+    ReadData2E = 64'h42508003FFFFFFFE;
+    ReadData3E = 64'h4010000000008FFE;
+    ans = 64'h7FFFBFFFFFFF7FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"162791\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFF0001FFFFFDFFF;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h3FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"163097\n");
+    end
+    ReadData1E = 64'h4000185761105E4D;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'h802FFFFFFF8007FF;
+    ans = 64'h4020185761105E4E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"163403\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h37FFFFFFFFFFF000;
+    ReadData3E = 64'h3F300000004FFFFF;
+    ans = 64'h3F300000004FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"163709\n");
+    end
+    ReadData1E = 64'hC80007FFFDFFFFFF;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"164015\n");
+    end
+    ReadData1E = 64'h43EFBFFFFFFFFFEE;
+    ReadData2E = 64'hBF4C00001FFFFFFF;
+    ReadData3E = 64'hBFDFFFFFE0200000;
+    ans = 64'hC34BC8001FBFFFF0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"164321\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'hC03C2DBB3FCD85BC;
+    ans = 64'hC03C2DBB3FCD85BC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"164627\n");
+    end
+    ReadData1E = 64'hDED0000000009000;
+    ReadData2E = 64'hCFF000000080001E;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h6ED000000080901E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"164933\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"165239\n");
+    end
+    ReadData1E = 64'hC01F00000001FFFF;
+    ReadData2E = 64'hD5F00040000007FF;
+    ReadData3E = 64'h001BCC611BF190C0;
+    ans = 64'h561F007C00020F85;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"165545\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hFFEFDFFFFFFFFDFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hC013EFFFFFFFFEFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"165851\n");
+    end
+    ReadData1E = 64'hFFF8000000000002;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'hC01FFFFF7FFFFBFE;
+    ans = 64'hFFF8000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"166157\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hDAC5722C9F775777;
+    ReadData3E = 64'hBCAF4D0647B4FC25;
+    ans = 64'hBCAF4D0647B4FC25;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"166463\n");
+    end
+    ReadData1E = 64'h5FC1FFFFFFFFFFF7;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'h6311FFFFFFFFFFF8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"166769\n");
+    end
+    ReadData1E = 64'hC8C0000000004001;
+    ReadData2E = 64'hC801E00000000000;
+    ReadData3E = 64'hBFFFFFE200000000;
+    ans = 64'h50D1E00000004781;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"167075\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h43D1FFFFFFFFFEFF;
+    ans = 64'h43D1FFFFFFFFFEFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"167381\n");
+    end
+    ReadData1E = 64'h3FF73F5B85DE8CFD;
+    ReadData2E = 64'hCC5FF00002000000;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'hCC6733BBD98F936F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"167687\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"167993\n");
+    end
+    ReadData1E = 64'h28D8C4D1B6B5D02A;
+    ReadData2E = 64'hC03000FBFFFFFFFF;
+    ReadData3E = 64'hC3E92D9F7CD3120F;
+    ans = 64'hC3E92D9F7CD3120F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"168299\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hBCAEFFFFFFFFFFFD;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h3FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"168605\n");
+    end
+    ReadData1E = 64'h3ABFFFFFC000001F;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'hC00C30DFF54218F0;
+    ans = 64'h7AAFFFFFC000001F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"168911\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC261FFFDFFFFFFFF;
+    ReadData3E = 64'h41FFFF00000001FF;
+    ans = 64'h41FFFF00000001FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"169217\n");
+    end
+    ReadData1E = 64'hA0237DD94E68EFEB;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'hE0137DD94E68EFEC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"169523\n");
+    end
+    ReadData1E = 64'hC19C000000000001;
+    ReadData2E = 64'h3FB03FFFFBFFFFFF;
+    ReadData3E = 64'hB7EFFEFFFEFFFFFF;
+    ans = 64'hC15C6FFFF8FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"169829\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h43CFFFFFEBFFFFFF;
+    ans = 64'h43CFFFFFEBFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"170135\n");
+    end
+    ReadData1E = 64'hD7DC200000000000;
+    ReadData2E = 64'hC80FF800007FFFFF;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h5FFC18F800707FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"170441\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC33FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"170747\n");
+    end
+    ReadData1E = 64'hB01A4F832C959609;
+    ReadData2E = 64'h89C82BFFE0C45E6D;
+    ReadData3E = 64'h8027D4762D411524;
+    ans = 64'h8027D4762D411524;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"171053\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC01FFFFFFFFFFF7F;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hBFD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"171359\n");
+    end
+    ReadData1E = 64'h3FBFFFFFFFFFFFFA;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h3801FFFFEFFFFFFF;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"171665\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h5380000040000200;
+    ReadData3E = 64'h402FFFFFFDFFFDFE;
+    ans = 64'h402FFFFFFDFFFDFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"171971\n");
+    end
+    ReadData1E = 64'hFFEB274EF24ABE39;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"172277\n");
+    end
+    ReadData1E = 64'h0A1FFFFFFFFF8200;
+    ReadData2E = 64'h400B6A2470F9D3B1;
+    ReadData3E = 64'h3F900000000010FE;
+    ans = 64'h3F900000000010FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"172583\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'h5110000000000000;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"172889\n");
+    end
+    ReadData1E = 64'hC1FBFFFE00000000;
+    ReadData2E = 64'h43FFFBFEFFFFFFFF;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"173195\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"173501\n");
+    end
+    ReadData1E = 64'h4020001F80000000;
+    ReadData2E = 64'hC060001080000000;
+    ReadData3E = 64'h3F1FFFFFFE001FFF;
+    ans = 64'hC090002FE0207C02;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"173807\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h070B0825C5EC0F5A;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'h3CAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"174113\n");
+    end
+    ReadData1E = 64'hBFCFFFC000002000;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FEFFFFFF8003FFF;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"174419\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hFFDA5511E91B29A4;
+    ReadData3E = 64'hC0132AF4F7353936;
+    ans = 64'hC019C039717C039F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"174725\n");
+    end
+    ReadData1E = 64'hB80C27A52E429300;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'h4000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"175031\n");
+    end
+    ReadData1E = 64'hB7E0400000000007;
+    ReadData2E = 64'h40168EE42D8C363C;
+    ReadData3E = 64'hC3EACA3042143FC7;
+    ans = 64'hC3EACA3042143FC7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"175337\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'hC80FFFFBFFFEFFFE;
+    ans = 64'hC80FFFFBFFFEFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"175643\n");
+    end
+    ReadData1E = 64'h3FFFFFFFE000007F;
+    ReadData2E = 64'hFFD833ECC0B49AAE;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FCF304D5DFD46C7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"175949\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hC00FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"176255\n");
+    end
+    ReadData1E = 64'h511FFFFFFFFF81FF;
+    ReadData2E = 64'h2C9D720D8566E997;
+    ReadData3E = 64'hD87A8F4E8B691515;
+    ans = 64'hD87A8F4E8B691515;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"176561\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FE00000001FFFFF;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'h40000000001FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"176867\n");
+    end
+    ReadData1E = 64'h3FEEFFFFFFF7FFFF;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'hC80FC00000FFFFFE;
+    ans = 64'hC80FC00000FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"177173\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h052FFFFFFFFEBFFE;
+    ReadData3E = 64'h52325DDDFABB70E9;
+    ans = 64'h52325DDDFABB70E9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"177479\n");
+    end
+    ReadData1E = 64'h41ED48B95654A033;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hBFF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"177785\n");
+    end
+    ReadData1E = 64'hFFD7D8EF2EB80057;
+    ReadData2E = 64'h47EC60B0CB2E134A;
+    ReadData3E = 64'h40FFFFFC00000002;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"178091\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'h001FFFFFC0000FFE;
+    ans = 64'h001FFFFFC0000FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"178397\n");
+    end
+    ReadData1E = 64'hBEF0003FDFFFFFFF;
+    ReadData2E = 64'h4020000000002002;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"178703\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'h4000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"179009\n");
+    end
+    ReadData1E = 64'h43DF719CD7AE4856;
+    ReadData2E = 64'h3FDFFFFFFFFEFFFD;
+    ReadData3E = 64'h4B400083FFFFFFFF;
+    ans = 64'h4B400083FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"179315\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC1CFFF000003FFFE;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'h81EFFEFFFF83FFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"179621\n");
+    end
+    ReadData1E = 64'h4006D160DC3E5934;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h47FFBFFFFBFFFFFF;
+    ans = 64'h47FFBFFFFBFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"179927\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h396DFC66107BEA99;
+    ReadData3E = 64'hC7EC00001FFFFFFE;
+    ans = 64'hC7EC00001FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"180233\n");
+    end
+    ReadData1E = 64'h547FFFFFCFFFFFFF;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h3FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"180539\n");
+    end
+    ReadData1E = 64'hB8085FDD8B928E73;
+    ReadData2E = 64'h3A7FFFFF80000020;
+    ReadData3E = 64'hC7EDF1DED100B9B0;
+    ans = 64'hC7EDF1DED100B9B0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"180845\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'h43CD9439FEC97506;
+    ans = 64'h43CD9439FEC97506;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"181151\n");
+    end
+    ReadData1E = 64'h41D0000200000002;
+    ReadData2E = 64'hBBD1C3DADDAEF6AB;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h4340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"181457\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hBFF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"181763\n");
+    end
+    ReadData1E = 64'hC0A00001FFFBFFFE;
+    ReadData2E = 64'hC04FFFFFFFF83FFF;
+    ReadData3E = 64'h7FD000009FFFFFFE;
+    ans = 64'h7FD000009FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"182069\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FEFDFFFEFFFFFFF;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h000FEFFFF7FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"182375\n");
+    end
+    ReadData1E = 64'h3A3FC00000000FFF;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'h3FBF800000010000;
+    ans = 64'h3FBF800000010000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"182681\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FFFFFFFE3FFFFFF;
+    ReadData3E = 64'h38100008000FFFFE;
+    ans = 64'h7FFFFFFFE3FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"182987\n");
+    end
+    ReadData1E = 64'h4090000007FFFFEF;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFE00000000007FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"183293\n");
+    end
+    ReadData1E = 64'h3FEFBFFFFFFFFFFA;
+    ReadData2E = 64'h4BD0200008000000;
+    ReadData3E = 64'h3E03C74E5B33E858;
+    ans = 64'h4BCFFF800FDFFFFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"183599\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFE0020007FFFFFE;
+    ans = 64'hBFE0020007FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"183905\n");
+    end
+    ReadData1E = 64'h802002000000007F;
+    ReadData2E = 64'hC7F41A21FDBC75B7;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"184211\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h3FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"184517\n");
+    end
+    ReadData1E = 64'h403FFF00001FFFFF;
+    ReadData2E = 64'hBFC0003FFFFFFEFF;
+    ReadData3E = 64'h3C6FFBFFFDFFFFFE;
+    ans = 64'hC00FFF7FFC1FFE7D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"184823\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC06FFFFF0003FFFE;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"185129\n");
+    end
+    ReadData1E = 64'h1BD0800000000004;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'h41F040000000003E;
+    ans = 64'h41F040000000003E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"185435\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h35E1FFFFFFFFBFFF;
+    ReadData3E = 64'h3FC00000017FFFFF;
+    ans = 64'h3FC00000017FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"185741\n");
+    end
+    ReadData1E = 64'hBB50000003FFFFBE;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"186047\n");
+    end
+    ReadData1E = 64'hBFE2B7291B588423;
+    ReadData2E = 64'h07000FDFFFFFFFFF;
+    ReadData3E = 64'h4340001FFFFFFF80;
+    ans = 64'h4340001FFFFFFF80;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"186353\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FE720695AC49CE9;
+    ans = 64'h7FE720695AC49CE9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"186659\n");
+    end
+    ReadData1E = 64'hC7E00000000000BF;
+    ReadData2E = 64'hBF899D7D5F337EFB;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h47799D7D5F33802D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"186965\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"187271\n");
+    end
+    ReadData1E = 64'hFFDFFFFFFFFBBFFF;
+    ReadData2E = 64'h7FEF000000000200;
+    ReadData3E = 64'h400FF8000007FFFF;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"187577\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h47F0FFFFFFFFDFFF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
@@ -14421,7189 +23974,11971 @@ initial
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
     	$fwrite(fp,"187883\n");
     end
-    x = 64'hC1C00001FFFFFFF7;
-    y = 64'hC00E5D7AC1BB31DB;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'h41DE5D7E8D6A8A01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3BDFFFFFDFFFFFFC;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'h30E000000081FFFE;
+    ans = 64'hBBCFFFFFDFFFFFFC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"188497\n");
+    	$fwrite(fp,"188189\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hC0AFF7FF00000000;
-    ans = 64'hC0AFF7FF00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hD34562EBF3B297C2;
+    ReadData3E = 64'hC1B0002003FFFFFF;
+    ans = 64'hC1B0002003FFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"189111\n");
+    	$fwrite(fp,"188495\n");
     end
-    x = 64'hB7F00000020003FF;
-    y = 64'h37F0000000077FFF;
-    z = 64'hC1F3DFFFFFFFFFFF;
-    ans = 64'hC1F3DFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3D0CC8372DBE587E;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCFD48372DBE5880;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"189725\n");
+    	$fwrite(fp,"188801\n");
     end
-    x = 64'hB9F25F96065D1F51;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC3EDFFF000000000;
+    ReadData2E = 64'hC07F00000000001F;
+    ReadData3E = 64'hC1F8C8FF1C1636A0;
+    ans = 64'h447D0FF07FFFE754;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"190339\n");
+    	$fwrite(fp,"189107\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hB7F8178C74E799A2;
-    z = 64'h3FB14A0681A30DCA;
-    ans = 64'h3FB14A0681A30DCA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FE0000020008000;
+    ans = 64'h3FE0000020008000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"190953\n");
+    	$fwrite(fp,"189413\n");
     end
-    x = 64'hB8002000000001FE;
-    y = 64'hBFF0000000000001;
-    z = 64'h400FFF800000000F;
-    ans = 64'h400FFF800000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"191567\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hB80E000000010000;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h3FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"192181\n");
-    end
-    x = 64'hFFEF50983C19207E;
-    y = 64'hB9CA0738168F7A54;
-    z = 64'hBFF7C2C7A0B00686;
-    ans = 64'h79C9788C353FC999;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"192795\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"193409\n");
-    end
-    x = 64'h3F1C000000FFFFFE;
-    y = 64'h3F5FF7FFFFFDFFFF;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h3E8BF90000FDFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"194023\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hC000000000000001;
-    z = 64'h3FB0000800000003;
-    ans = 64'h3FB0000800000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"194637\n");
-    end
-    x = 64'hC3CFE00000007FFF;
-    y = 64'hC1D01000000FFFFF;
-    z = 64'h3FFFFFFEFFFFFFFF;
-    ans = 64'h45AFFFE00020607D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"195251\n");
-    end
-    x = 64'h47EA12AFD077048D;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC80A12AFD077048C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"195865\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hC80C919352460A7E;
-    z = 64'h43C4A5E1CCDA6E01;
-    ans = 64'h43C4A5E1CCDA6E01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"196479\n");
-    end
-    x = 64'h3F2CBAF78B0FA58F;
-    y = 64'hC010000000000000;
-    z = 64'h3CCD7C6CEDAF0060;
-    ans = 64'hBF4CBAF78B0F8813;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"197093\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hBFBFFDF7FFFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h3FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"197707\n");
-    end
-    x = 64'h43D02FFFFFFFFFFE;
-    y = 64'h37F0000001FFFFFD;
-    z = 64'h3F9D452BB58B7274;
-    ans = 64'h3F9D452BB58B7274;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"198321\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFE;
+    ReadData1E = 64'hBCDFFFEFFFFEFFFF;
+    ReadData2E = 64'h309FFFC800000000;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
     ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"198935\n");
+    	$fwrite(fp,"189719\n");
     end
-    x = 64'h41EFFFFFFFDFFFF0;
-    y = 64'h3F100000020001FE;
-    z = 64'h8010000000000000;
-    ans = 64'h4110000001F001F6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"199549\n");
+    	$fwrite(fp,"190025\n");
     end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hC340000000000000;
-    z = 64'hBFBFEFFBFFFFFFFF;
-    ans = 64'hBFBFEFFBFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC0EEFFFFFF7FFFFF;
+    ReadData2E = 64'hB7FFFFF9FFFFFFFF;
+    ReadData3E = 64'hBFFFFFFEEFFFFFFF;
+    ans = 64'hBFFFFFFEEFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"200163\n");
+    	$fwrite(fp,"190331\n");
     end
-    x = 64'h3FEFFFFFFFFFFF83;
-    y = 64'hBFB005FFFFFFFFFE;
-    z = 64'h21E00000080003FE;
-    ans = 64'hBFB005FFFFFFFFBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"200777\n");
-    end
-    x = 64'h491FFFFFFFFFBFFF;
-    y = 64'hC340000000000001;
-    z = 64'hC340000000000000;
-    ans = 64'hCC6FFFFFFFFFC001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"201391\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hC010000020000400;
-    z = 64'h400FFFFF807FFFFF;
-    ans = 64'h400FFFFF807FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"202005\n");
-    end
-    x = 64'hC1CFFE07FFFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h47A00000003DFFFF;
-    ans = 64'h47A00000003E1FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"202619\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h54200007FFFFE000;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"203233\n");
-    end
-    x = 64'h4C2FFFFFFDFEFFFF;
-    y = 64'h480FFFFFFFF7E000;
-    z = 64'hC7E0000000FFFFF8;
-    ans = 64'h544FFFFFFDF6DFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"203847\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hFFE0000000000001;
-    z = 64'hBFF0000000000000;
-    ans = 64'hC008000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"204461\n");
-    end
-    x = 64'h410E63FF6A5527C8;
-    y = 64'hB7E0B3FE678F16FD;
-    z = 64'h8000000000000001;
-    ans = 64'hB8FFB9E15BF4FE1E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"205075\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h000000000000007C;
-    ans = 64'hC00FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"205689\n");
-    end
-    x = 64'h3FF0E30D389CC2AC;
-    y = 64'hC1FFFFFFEFFFFFFB;
-    z = 64'hA8D20000000003FF;
-    ans = 64'hC200E30D302B3C0D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"206303\n");
-    end
-    x = 64'h480FFFFF7FFFFBFE;
-    y = 64'hFFF0000000000000;
-    z = 64'hC010000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"206917\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'h413000007FFC0000;
-    z = 64'h7FFFFF8000000800;
-    ans = 64'h7FFFFF8000000800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"207531\n");
-    end
-    x = 64'hC01FBFFFFFFFFFFC;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h7FEF7FFFFBFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"208145\n");
-    end
-    x = 64'h000FFFFFFFFFFFFF;
-    y = 64'hC037A6B29B795033;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"208759\n");
-    end
-    x = 64'h74501FFFE0000000;
-    y = 64'hFFDFF25176E4987F;
-    z = 64'h41F07FFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"209373\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h0000000000000000;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"209987\n");
-    end
-    x = 64'hC3F0000001000002;
-    y = 64'h403FBFFFFFFFFFBF;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"210601\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hB81FFFFFFFFF0002;
-    ans = 64'hB81FFFFFFFFF0002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"211215\n");
-    end
-    x = 64'h7FF9CDC93C37E5CE;
-    y = 64'h144BFFFF80000000;
-    z = 64'h3FE800000001FFFE;
-    ans = 64'h7FF9CDC93C37E5CE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"211829\n");
-    end
-    x = 64'hC03F80000000000E;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"212443\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hC3E02000FFFFFFFE;
-    z = 64'h4351FFFF00000000;
-    ans = 64'h4351FFFF00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"213057\n");
-    end
-    x = 64'h3FEFF7FFFBFFFFFF;
-    y = 64'h0010000000000001;
-    z = 64'hC7EFFFFFFFEFDFFE;
-    ans = 64'hC7EFFFFFFFEFDFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"213671\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h50464308CED89F99;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"214285\n");
-    end
-    x = 64'h3C70000000FFF000;
-    y = 64'h3C6FFFFDF0000000;
-    z = 64'hC801BD5FB5B87EDD;
-    ans = 64'hC801BD5FB5B87EDD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"214899\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"215513\n");
-    end
-    x = 64'hC03FFFEFFBFFFFFF;
-    y = 64'h403FF7EFFFFFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"216127\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h3CA0000000000001;
-    z = 64'hBDAFF7EFFFFFFFFF;
-    ans = 64'hBDAFF7EFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"216741\n");
-    end
-    x = 64'hB0700001FFDFFFFF;
-    y = 64'h47F0000000000010;
-    z = 64'hC0F824C774FC96AC;
-    ans = 64'hC0F824C774FC96AC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"217355\n");
-    end
-    x = 64'h4C7FFFFC00004000;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'h493FFFFC00003FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"217969\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h4038FCF2DDB95CD2;
-    z = 64'h64F000000007FFF8;
-    ans = 64'h64F000000007FFF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"218583\n");
-    end
-    x = 64'h3E5E2E6A53E9291B;
-    y = 64'h3FD0000000000000;
-    z = 64'hC0ACC1E0EADB27EE;
-    ans = 64'hC0ACC1E0EADAEB91;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"219197\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h4EEFFFE000000020;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h0F0FFFE00000001C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"219811\n");
-    end
-    x = 64'h40FBC1EF86378DB0;
-    y = 64'h3FD1000FFFFFFFFF;
-    z = 64'hBFB00BFFFFFFFFFE;
-    ans = 64'h40DD7E263D8A8CC1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"220425\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBCAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"221039\n");
-    end
-    x = 64'h47F74CDAF7D04AC1;
-    y = 64'h3FBDFFFFFFFFFF80;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"221653\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h3FE0000000000000;
-    z = 64'hC3C00007F8000000;
-    ans = 64'hC3C00007F8000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"222267\n");
-    end
-    x = 64'h22FFFFFFFFFFBFFC;
-    y = 64'hFDA7FFFFC0000000;
-    z = 64'h3CAFFFFFFFFFE7FE;
-    ans = 64'hE0B7FFFFBFFFCFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"222881\n");
-    end
-    x = 64'hD8D00000FFBFFFFF;
-    y = 64'h3FE0000000000001;
-    z = 64'hBFF0000000000000;
-    ans = 64'hD8C00000FFC00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"223495\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hBCAFFFFBFFFFFFF7;
-    z = 64'hC28FFFFFF0003FFF;
-    ans = 64'hC28FFFFFF0003FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"224109\n");
-    end
-    x = 64'h3FB2000000000400;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h47F7DD98F7C2DED1;
-    ans = 64'h47F7DD98F7C2DED1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"224723\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h3FBFFDFFFFFFFFEF;
-    z = 64'h0010000000000000;
-    ans = 64'h0011FFDFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"225337\n");
-    end
-    x = 64'hBFB0000000280000;
-    y = 64'h41803F7FFFFFFFFF;
-    z = 64'h802465A3B9118621;
-    ans = 64'hC1403F8000289EBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"225951\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h3FF0000000000001;
-    z = 64'hBCA0000000000000;
-    ans = 64'hBCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"226565\n");
-    end
-    x = 64'hBF8FFFE000020000;
-    y = 64'hC03FF000007FFFFF;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"227179\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'hC3D01F75DBA36D94;
-    ans = 64'hC3D01F75DBA36D94;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"227793\n");
-    end
-    x = 64'hC80FFFFE000003FF;
-    y = 64'hAAC00000040001FF;
-    z = 64'h4AF74822E4CB078B;
-    ans = 64'h4AF74822E4CB078B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"228407\n");
-    end
-    x = 64'hC6530B18D3D732F8;
-    y = 64'h4000000000000000;
-    z = 64'hBFE0000000000001;
-    ans = 64'hC6630B18D3D732F8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"229021\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h40D00000002FFFFE;
-    z = 64'hBF8FFFFF7EFFFFFE;
-    ans = 64'hBF8FFFFF7EFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"229635\n");
-    end
-    x = 64'h2A1FFFFFFF7FFFFF;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h582FFFFFFFFFFC01;
-    ans = 64'h582FFFFFFFFFFC01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"230249\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h41DFFFFFFFFFF900;
-    z = 64'h0000000000000001;
-    ans = 64'h01FFFFFFFFFFF8FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"230863\n");
-    end
-    x = 64'h416A5A4987DB72F7;
-    y = 64'hBFCFFFFFFF7FFFF7;
-    z = 64'h3F90040FFFFFFFFF;
-    ans = 64'hC14A5A49857187C9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"231477\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h4010000000000000;
-    z = 64'h8010000000000001;
-    ans = 64'h0027FFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"232091\n");
-    end
-    x = 64'hC02C30BECB2AD454;
-    y = 64'hBFBFFFFFFFE00400;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h40238617D961D4E3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"232705\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h43E0000000040400;
-    ans = 64'h43E0000000040400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"233319\n");
-    end
-    x = 64'h3FEFFFFFFFFF3FFF;
-    y = 64'h3FC89C5029E5BAE3;
-    z = 64'hBFFFFFFFFFFBFC00;
-    ans = 64'hBFFCEC75FABF5719;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"233933\n");
-    end
-    x = 64'hBFF000000000004F;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hC02100000000004E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"234547\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h3F0FFFFE7FFFFFFE;
-    z = 64'h3FEFF00007FFFFFF;
-    ans = 64'h3FEFF00007FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"235161\n");
-    end
-    x = 64'h37FA13DD98EDB441;
-    y = 64'h4340000000000001;
-    z = 64'h81454CE0E2690CED;
-    ans = 64'h3B4A13DD98EDB443;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"235775\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h43EFFFFFFFFF801E;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"236389\n");
-    end
-    x = 64'hC0007FFFFFFFBFFE;
-    y = 64'hBFDFFFFFFFFDFF80;
-    z = 64'hC2A2BD5FA60F3DDE;
-    ans = 64'hC2A2BD5FA60F3BCE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"237003\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h036FFFFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"237617\n");
-    end
-    x = 64'h756FFFFFFC00003E;
-    y = 64'h3CF587D08EB672DD;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h727587D08C0578F5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"238231\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h7FE0000000000001;
-    z = 64'hC00FFFFFC0000002;
-    ans = 64'hBFFFFFFF80000006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"238845\n");
-    end
-    x = 64'h41F0000000008FFE;
-    y = 64'hB8000010FFFFFFFE;
-    z = 64'hBFFD9D819A979570;
-    ans = 64'hBFFD9D819A979570;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"239459\n");
-    end
-    x = 64'h3111F5E51199ED7F;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'h7111F5E51199ED7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"240073\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hC34E000000000200;
-    z = 64'h7FF0000000000C00;
-    ans = 64'h7FF8000000000C00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"240687\n");
-    end
-    x = 64'h001000000200FFFF;
-    y = 64'h7FF0000000000000;
-    z = 64'h43D00FFFFFFFFFF7;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"241301\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hC03C00000000003F;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"241915\n");
-    end
-    x = 64'h3F8FFFFF7F7FFFFE;
-    y = 64'hB1BFFBFFFFFFFFC0;
-    z = 64'h3C9FFFBFFFFFFF7F;
-    ans = 64'h3C9FFFBFFFFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"242529\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"243143\n");
-    end
-    x = 64'h402A5DF48F98AD36;
-    y = 64'h381FFFFFFEFFFFFD;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"243757\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h8000000000000000;
-    z = 64'hB33288221059078A;
-    ans = 64'hB33288221059078A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"244371\n");
-    end
-    x = 64'h814931D84B67C1AA;
-    y = 64'h480FDFFFFFFC0000;
-    z = 64'h41F00FFFFDFFFFFF;
-    ans = 64'h41F00FFFFDFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"244985\n");
-    end
-    x = 64'hC0F2D69C32093435;
-    y = 64'h8000000000000001;
-    z = 64'hBCA0000000000000;
-    ans = 64'hBCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"245599\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hBFDFFFFFF0200000;
-    z = 64'hC7FFD80000000000;
-    ans = 64'hC7FFD80000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"246213\n");
-    end
-    x = 64'hB813FC0000000000;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h7FDFFFFEC0000000;
-    ans = 64'h7FDFFFFEC0000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"246827\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hBBD1FFFFFFFFFFFF;
-    z = 64'hFFE0000000000000;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC3C000010003FFFF;
+    ReadData3E = 64'hFFE0000000000000;
     ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"247441\n");
+    	$fwrite(fp,"190637\n");
     end
-    x = 64'h41C180E153D6F2EC;
-    y = 64'hC03F020000000000;
-    z = 64'h3FE7DDEDE7BDA1DF;
-    ans = 64'hC210F5F2574A7D06;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hD83FFFFEBFFFFFFE;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'h48A000007FFFBFFF;
+    ans = 64'h583FFFFEBFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"248055\n");
+    	$fwrite(fp,"190943\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h8010000000000001;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hA21FFFFFDBFFFFFF;
+    ReadData3E = 64'h3EC0000100000000;
+    ans = 64'h3EC0000100000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"248669\n");
+    	$fwrite(fp,"191249\n");
     end
-    x = 64'h380C4BA9646D43BB;
-    y = 64'hBE06F94240DDBEA5;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC00FFFC000003FFF;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h400FFFC000004001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"249283\n");
+    	$fwrite(fp,"191555\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hC021000000000000;
-    ans = 64'hC021000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h43F08000003FFFFF;
+    ReadData2E = 64'h43F0000000010007;
+    ReadData3E = 64'h3FD000008000003F;
+    ans = 64'h47F0800000410806;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"249897\n");
+    	$fwrite(fp,"191861\n");
     end
-    x = 64'h3FD8B6FF3FCFD46E;
-    y = 64'h001FFFFFFFFFEFFF;
-    z = 64'hA97074FAD68B5F25;
-    ans = 64'hA97074FAD68B5F25;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'h402FFFFFFFEFFFE0;
+    ans = 64'h402FFFFFFFEFFFE0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"250511\n");
+    	$fwrite(fp,"192167\n");
     end
-    x = 64'hB7EBFF0000000000;
-    y = 64'hBCA0000000000000;
-    z = 64'h8010000000000001;
-    ans = 64'h349BFF0000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFCFFFFFF0001000;
+    ReadData2E = 64'hBFFFFFFFE1000000;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h3FF7FFFFF4400404;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"251125\n");
+    	$fwrite(fp,"192473\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hC96FFFFFFF8001FF;
-    z = 64'h40DFFFFFFDFFFFFC;
-    ans = 64'h40DFFFFFFDFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCA0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"251739\n");
+    	$fwrite(fp,"192779\n");
     end
-    x = 64'h801C7B84A75451DD;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h43FFBFFDFFFFFFFF;
-    ans = 64'h43FFBFFDFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB050000000000080;
+    ReadData2E = 64'hC040000000023FFE;
+    ReadData3E = 64'hC5F0001FFFFC0000;
+    ans = 64'hC5F0001FFFFC0000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"252353\n");
+    	$fwrite(fp,"193085\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h3FEBFC64B17CA8B8;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h70CFFFFFF007FFFF;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"252967\n");
+    	$fwrite(fp,"193391\n");
     end
-    x = 64'h43FFFFFFFFFE003F;
-    y = 64'hB9BFFFDFFFF00000;
-    z = 64'hBE7E335C0C10AACF;
-    ans = 64'hBE7E375C0810A88F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h39E0400200000000;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h93BDEDDC1C831F20;
+    ans = 64'hB9F04001FFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"253581\n");
+    	$fwrite(fp,"193697\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hBFD0000000000000;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC004002000000000;
+    ReadData3E = 64'h3F40000002007FFF;
+    ans = 64'h3F40000002007FFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"254195\n");
+    	$fwrite(fp,"194003\n");
     end
-    x = 64'hC02FFFFFFEFFEFFF;
-    y = 64'hBA0FFFFF803FFFFF;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h401E2A166710BDF4;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'hC02E2A166710BDF4;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"254809\n");
+    	$fwrite(fp,"194309\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hBFD0000000000001;
-    z = 64'hC3F007DFFFFFFFFE;
-    ans = 64'hC3F007DFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h47F7FFFFFFFFFE00;
+    ReadData2E = 64'hBCAA2259CDEBD65C;
+    ReadData3E = 64'h43E0000004000003;
+    ans = 64'hC4B399435A70BF23;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"255423\n");
+    	$fwrite(fp,"194615\n");
     end
-    x = 64'hB81B6C5020C693B9;
-    y = 64'h8010A73398D14A63;
-    z = 64'hBF9C0A2129066A92;
-    ans = 64'hBF9C0A2129066A92;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'h93EFFFFFFFF800FE;
+    ans = 64'h93EFFFFFFFF800FE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"256037\n");
+    	$fwrite(fp,"194921\n");
     end
-    x = 64'hC3D0000000000FBE;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h43C0000000000FBD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hAC0EEB91BA0B67AB;
+    ReadData2E = 64'h344007FFFFFF7FFF;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'hBFE0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"256651\n");
+    	$fwrite(fp,"195227\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h3E0FFFFC0003FFFE;
-    z = 64'h37EFFE0000000400;
-    ans = 64'h37EFFE0000000400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h801FFFFFFFFFFFFB;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"257265\n");
+    	$fwrite(fp,"195533\n");
     end
-    x = 64'h43EFBFFFFF000000;
-    y = 64'hBFE0000000000001;
-    z = 64'h402C00007FFFFFFF;
-    ans = 64'hC3DFBFFFFF000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC021FFFFFFFFDFFF;
+    ReadData2E = 64'h54B000000000002E;
+    ReadData3E = 64'h77C7FFFBFFFFFFFE;
+    ans = 64'h77C7FFFBFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"257879\n");
+    	$fwrite(fp,"195839\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h41FFDFFFFFFFF000;
-    z = 64'hC01FFFFFFFFFFFFF;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC02FFFFFFF7FFBFE;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
     ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"258493\n");
+    	$fwrite(fp,"196145\n");
     end
-    x = 64'h400FFFFFF9FFFFFE;
-    y = 64'hBFEFFFC000020000;
-    z = 64'h41E0000047FFFFFF;
-    ans = 64'h41E00000478000FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC6CC000000007FFF;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'hC02FFDFFFFFFFDFF;
+    ans = 64'h46EC000000007FFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"259107\n");
+    	$fwrite(fp,"196451\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h36EE3366425C75C8;
+    ReadData3E = 64'hC01E3475BEDA42B8;
+    ans = 64'hC01E3475BEDA42B8;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"259721\n");
+    	$fwrite(fp,"196757\n");
     end
-    x = 64'hC0170040464CFE1F;
-    y = 64'h311C000007FFFFFF;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBF27000000000000;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'h3F47000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"260335\n");
+    	$fwrite(fp,"197063\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hBFF0000000000000;
-    z = 64'h43EFFFFF80000001;
-    ans = 64'h43EFFFFF80000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h43E0080007FFFFFF;
+    ReadData2E = 64'hBE6000021FFFFFFF;
+    ReadData3E = 64'hBE0FFF6FFFFFFFFE;
+    ans = 64'hC25008022910010E;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"260949\n");
+    	$fwrite(fp,"197369\n");
     end
-    x = 64'hC023FFFFFBFFFFFE;
-    y = 64'hB7E56E0E64D01FD4;
-    z = 64'hB81306B461C19607;
-    ans = 64'h37FF0B765B9C3898;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'hBFCFFFFBFFFF7FFE;
+    ans = 64'hBFCFFFFBFFFF7FFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"261563\n");
+    	$fwrite(fp,"197675\n");
     end
-    x = 64'hFFE92C9C9F15452B;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h18B000000007EFFF;
+    ReadData2E = 64'h434FFFBFFEFFFFFE;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h3FDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"262177\n");
+    	$fwrite(fp,"197981\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h406FFFF80003FFFF;
-    z = 64'h8022000000000008;
-    ans = 64'h008FB7F80003FFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h8033FFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"262791\n");
+    	$fwrite(fp,"198287\n");
     end
-    x = 64'h3DBFFFFFFC000000;
-    y = 64'hC000000000000000;
-    z = 64'h381FFFFFFFFDFFBF;
-    ans = 64'hBDCFFFFFFC000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h37E000000FFFFFF6;
+    ReadData2E = 64'h33D6647C02C60C56;
+    ReadData3E = 64'hB7E00800007FFFFF;
+    ans = 64'hB7E00800007FFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"263405\n");
+    	$fwrite(fp,"198593\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hC1900000023FFFFF;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FDA473ACD6FEEA1;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h401691CEB35BFBA7;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"264019\n");
+    	$fwrite(fp,"198899\n");
     end
-    x = 64'hBFDFF0000000003F;
-    y = 64'hBFD00000000FBFFE;
-    z = 64'hE06FFFFFFFDBFFFF;
-    ans = 64'hE06FFFFFFFDBFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFC00000000;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'hC02FFFFFFFFFFFFF;
+    ans = 64'hC033FFFF7FFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"264633\n");
+    	$fwrite(fp,"199205\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h3BBFA0C90CC4D322;
+    ReadData3E = 64'hC1EFFFFFFFFEF7FF;
+    ans = 64'hC1EFFFFFFFFEF7FF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"265247\n");
+    	$fwrite(fp,"199511\n");
     end
-    x = 64'hC7E0000000007FEF;
-    y = 64'h381000FFF7FFFFFE;
-    z = 64'h3FD0000000000000;
-    ans = 64'hBFFC01FFF000FFEA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3F6D51D89575BCC2;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"265861\n");
+    	$fwrite(fp,"199817\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hD50FFFF7FFC00000;
-    ans = 64'hD50FFFF7FFC00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB7ED478C97EEF482;
+    ReadData2E = 64'hBFFBFF8000000000;
+    ReadData3E = 64'hED7FFFFF00000010;
+    ans = 64'hED7FFFFF00000010;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"266475\n");
+    	$fwrite(fp,"200123\n");
     end
-    x = 64'hC3E8EC94F987EA69;
-    y = 64'hB6BFFE000007FFFF;
-    z = 64'h7FEFFFFFFBFFFFBF;
-    ans = 64'h7FEFFFFFFBFFFFBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'hC1C0000001FFFBFF;
+    ans = 64'hC1C0000001FFFBFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"267089\n");
+    	$fwrite(fp,"200429\n");
     end
-    x = 64'hBF205FF2A7EAB3BB;
-    y = 64'hC010000000000001;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FE0001FFFFFF7FF;
+    ReadData2E = 64'h434FFFFFFFFFFBF7;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'h4340001FFFFFF5FA;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"267703\n");
+    	$fwrite(fp,"200735\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'h47F0000000007FFD;
-    z = 64'h7FDFFFFFFFFFFFFF;
-    ans = 64'h7FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'h8360000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"268317\n");
+    	$fwrite(fp,"201041\n");
     end
-    x = 64'hB5A9CE7F4AAD3C58;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hBFE000000020000E;
-    ans = 64'hBFE000000020000E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3815CFAC7B87B8E2;
+    ReadData2E = 64'h4342C0A02E3CB0AF;
+    ReadData3E = 64'hBCA00020001FFFFE;
+    ans = 64'hBCA0001E671C7836;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"268931\n");
+    	$fwrite(fp,"201347\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hC039B54B40228093;
-    z = 64'hC000000000000000;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC3E3BFFFFFFFFFFF;
+    ReadData3E = 64'hC000000000000000;
     ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"269545\n");
+    	$fwrite(fp,"201653\n");
     end
-    x = 64'hBF8FFFFC007FFFFF;
-    y = 64'h43C00007FFFFFDFF;
-    z = 64'hBF60800FFFFFFFFE;
-    ans = 64'hC3600006003EFE1F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"270159\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hC340000000000001;
-    z = 64'h4010000000000000;
-    ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"270773\n");
-    end
-    x = 64'hBF400020007FFFFF;
-    y = 64'h801423605653ABED;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3CA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"271387\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hC3C00000040FFFFF;
-    ans = 64'hC3C00000040FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"272001\n");
-    end
-    x = 64'h3FDFFFFFFFFFFC04;
-    y = 64'hC3ED280F8FC308D0;
-    z = 64'hC890000000803FFF;
-    ans = 64'hC890000000803FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"272615\n");
-    end
-    x = 64'h349FFFFFFFFDFFDF;
-    y = 64'hFFE0000000000000;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"273229\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hC1D03FFFFFFFFFEF;
-    z = 64'hB7E598841B7B4A99;
-    ans = 64'hB7E598841B7B4A99;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"273843\n");
-    end
-    x = 64'h2D8FFFFFFFFFFBBE;
-    y = 64'hFFE0000000000001;
-    z = 64'h403FC0003FFFFFFE;
-    ans = 64'hED7FFFFFFFFFFBC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"274457\n");
-    end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hBFDFC00020000000;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"275071\n");
-    end
-    x = 64'h41DFFFF7FFFFFFDE;
-    y = 64'hFFE0000FFFFF8000;
-    z = 64'h40357503F165F219;
+    ReadData1E = 64'h7FE0400000800000;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'h43FFFFFDFFFFFFBF;
     ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"275685\n");
+    	$fwrite(fp,"201959\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hFFF0000000000000;
-    z = 64'h4000000000000001;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hB81FFFFFFF800008;
+    ReadData3E = 64'h3FEFFFFFFF8FFFFF;
+    ans = 64'h3FEFFFFFFF8FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"202265\n");
+    end
+    ReadData1E = 64'h41CFFFEFFFFFFFFD;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"202571\n");
+    end
+    ReadData1E = 64'hC1DFFFFFFE007FFF;
+    ReadData2E = 64'h37F003FFEFFFFFFF;
+    ReadData3E = 64'hBFA26A7786C5CB13;
+    ans = 64'hBFA26A7786C5CB13;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"202877\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'h001F000000000006;
+    ans = 64'h836FFFFFFFFFFFFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"203183\n");
+    end
+    ReadData1E = 64'hB80FEFFFFFE00000;
+    ReadData2E = 64'hD3BFFC00001FFFFF;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h4BDFEC01FFFFF3FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"203489\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"203795\n");
+    end
+    ReadData1E = 64'h402FFFFFFFFE7FFE;
+    ReadData2E = 64'hC0D5A7AD5AE857AD;
+    ReadData3E = 64'hCAD5D349067B07E9;
+    ans = 64'hCAD5D349067B07E9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"204101\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC06FFFFFFBBFFFFF;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h3FF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"204407\n");
+    end
+    ReadData1E = 64'h4EF101FFFFFFFFFE;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hBFC400000FFFFFFE;
     ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"276299\n");
+    	$fwrite(fp,"204713\n");
     end
-    x = 64'hC2CC000003FFFFFE;
-    y = 64'h55E7FFFFFFFFFFEE;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'hD8C5000002FFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'h402FFFFFF7FFFFFD;
+    ReadData3E = 64'hBC0DFFFFFFFFFDFF;
+    ans = 64'hBC0DFFFFFFFFFDFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"276913\n");
+    	$fwrite(fp,"205019\n");
     end
-    x = 64'h000FFFFFFFFFFFFE;
-    y = 64'hFFF0000000000001;
-    z = 64'hDD54F217C468808E;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC18A72215CF98D87;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"277527\n");
+    	$fwrite(fp,"205325\n");
     end
-    x = 64'hBFC000000002FFFE;
-    y = 64'h401FFEFFFFFFFDFF;
-    z = 64'h405634FB9C49B286;
-    ans = 64'h4055F4FD9C49A68A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC10FFFFFFFFFE000;
+    ReadData2E = 64'hFFF0576627B050D5;
+    ReadData3E = 64'hB80DFFFFFBFFFFFF;
+    ans = 64'hFFF8576627B050D5;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"278141\n");
+    	$fwrite(fp,"205631\n");
     end
-    x = 64'hBFF080003FFFFFFE;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hC1D03FFFF0000000;
+    ans = 64'hC1D03FFFF1000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"278755\n");
+    	$fwrite(fp,"205937\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h43D00FEFFFFFFFFF;
-    z = 64'hB06EA04ADE201D7F;
-    ans = 64'hB06EA04ADE201D7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBE18A0CAC8A2538B;
+    ReadData2E = 64'hBF1FFFFFFFFE003F;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h3D48A0CAC8A0C9AF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"279369\n");
+    	$fwrite(fp,"206243\n");
     end
-    x = 64'h43C04000000001FE;
-    y = 64'h0000000000000000;
-    z = 64'hEE69F3C54C8FF937;
-    ans = 64'hEE69F3C54C8FF937;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"279983\n");
+    	$fwrite(fp,"206549\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'hBFB418FF0ADFC0EF;
-    z = 64'hBFEFFFFFFFFFFFFF;
+    ReadData1E = 64'hBF7FFC000000007F;
+    ReadData2E = 64'h480BFFFFFC000000;
+    ReadData3E = 64'h7FD0E7C95060F159;
+    ans = 64'h7FD0E7C95060F159;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"206855\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC68000000003FFFE;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
     ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"280597\n");
+    	$fwrite(fp,"207161\n");
     end
-    x = 64'hC0EFFFFFFF800200;
-    y = 64'h403000000080FFFF;
-    z = 64'h3FE0082386A444A3;
-    ans = 64'hC12FFFFEFFFFC994;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h53B00003FFFFFF7F;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'hC0480001FFFFFFFF;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"281211\n");
+    	$fwrite(fp,"207467\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h3FFFFFFFFFFFFFFF;
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hC03FFFFE00000002;
+    ReadData3E = 64'h40A4791D49CC2DB1;
+    ans = 64'h40A4791D49CC2DB1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"207773\n");
+    end
+    ReadData1E = 64'hBFA00001DFFFFFFF;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"208079\n");
+    end
+    ReadData1E = 64'hB8000000FFFFF7FF;
+    ReadData2E = 64'hBFDFFE0000000003;
+    ReadData3E = 64'h41E00800000000FF;
+    ans = 64'h41E00800000000FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"208385\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFDF7FBFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"208691\n");
+    end
+    ReadData1E = 64'hB80FDFFFFFFFFDFF;
+    ReadData2E = 64'hC3C0000000400002;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h3BDFE000007F7E03;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"208997\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFF;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"209303\n");
+    end
+    ReadData1E = 64'h3FB800007FFFFFFF;
+    ReadData2E = 64'h7C30000003FFFFE0;
+    ReadData3E = 64'hB7EF87FFFFFFFFFF;
+    ans = 64'h7BF8000085FFFFEF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"209609\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBCA39AB8CC6231C7;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h3FDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"209915\n");
+    end
+    ReadData1E = 64'h418FE00000000000;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'hBCA007FFDFFFFFFE;
+    ans = 64'hBCA007FFDFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"210221\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hDDF0001FF7FFFFFF;
+    ReadData3E = 64'h40301FFFFFFFFFF8;
+    ans = 64'h40301FFFFFFFFFF8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"210527\n");
+    end
+    ReadData1E = 64'hC09000DFFFFFFFFE;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h4010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"210833\n");
+    end
+    ReadData1E = 64'h41C10000000001FE;
+    ReadData2E = 64'h40A2D6D7190048EE;
+    ReadData3E = 64'h3FB0400FFFFFFFFF;
+    ans = 64'h427404448A9050D9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"211139\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'h3F600000101FFFFE;
+    ans = 64'h3F600000101FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"211445\n");
+    end
+    ReadData1E = 64'h403FFFFFFFFFFFF9;
+    ReadData2E = 64'hC7F0001080000000;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"211751\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'hC340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"212057\n");
+    end
+    ReadData1E = 64'h47F00FFFFF7FFFFF;
+    ReadData2E = 64'h3F08F8194952D2A2;
+    ReadData3E = 64'h3FE6D31424C9EF4B;
+    ans = 64'h4709111161D464A9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"212363\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFD00040000003FF;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'hBFD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"212669\n");
+    end
+    ReadData1E = 64'h348EE00000000000;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'hBF2FFF7FFFFFDFFE;
+    ans = 64'hBF2FFF7FFFFFDFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"212975\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC1D84EFBB512A72A;
+    ReadData3E = 64'hBE69AF2F69623970;
+    ans = 64'hBE69AF2F69623970;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"213281\n");
+    end
+    ReadData1E = 64'hBFFAA0994C9B21E2;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hC00FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"213587\n");
+    end
+    ReadData1E = 64'h3A3FFFFFDFF80000;
+    ReadData2E = 64'h40900000000E0000;
+    ReadData3E = 64'hBFE0FFE000000000;
+    ans = 64'hBFE0FFE000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"213893\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'hD8A8756C95FF9ED8;
+    ans = 64'hD8A8756C95FF9ED8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"214199\n");
+    end
+    ReadData1E = 64'h59DFFFFFFE0007FE;
+    ReadData2E = 64'hC9C000FFFFFFC000;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"214505\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h4010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"214811\n");
+    end
+    ReadData1E = 64'h43E256FC6CB56CC4;
+    ReadData2E = 64'h7FD0001000000000;
+    ReadData3E = 64'hBFF00000203FFFFF;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"215117\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h001FFFFBFFFFF800;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'h3CA0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"215423\n");
+    end
+    ReadData1E = 64'hB7FD14550750159C;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'hC7E00007FFEFFFFF;
+    ans = 64'hC7E00007FFEFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"215729\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBEBCCD02BE345203;
+    ReadData3E = 64'h439FFFFFFFFFFF80;
+    ans = 64'h439FFFFFFFFFFF80;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"216035\n");
+    end
+    ReadData1E = 64'hC3D000087FFFFFFF;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'hC07FE010FFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"216341\n");
+    end
+    ReadData1E = 64'hC04000000F7FFFFF;
+    ReadData2E = 64'hC4AFFFFC00000010;
+    ReadData3E = 64'hC1EFFFFFFFF7DFFE;
+    ans = 64'h44FFFFFC1EFFFC1E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"216647\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h41EFE05B7227E188;
+    ans = 64'h41EFE05B7227E188;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"216953\n");
+    end
+    ReadData1E = 64'hC26E000000000000;
+    ReadData2E = 64'h002FFFF77FFFFFFF;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"217259\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hC00FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"217565\n");
+    end
+    ReadData1E = 64'hC63FFFFFDFEFFFFF;
+    ReadData2E = 64'h40100000000000FC;
+    ReadData3E = 64'h47F76CA910E9A48C;
+    ans = 64'h47F76CA908E9A494;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"217871\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3330000000000803;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h801FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"218177\n");
+    end
+    ReadData1E = 64'hB7EFFFFFFEFBFFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'hB7F2007FFFFFFFFF;
+    ans = 64'hB7F2008000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"218483\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h37E60289AEF484C8;
+    ReadData3E = 64'hC0E000000BFFFFFE;
+    ans = 64'hC0E000000BFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"218789\n");
+    end
+    ReadData1E = 64'h3CA0007EFFFFFFFE;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"219095\n");
+    end
+    ReadData1E = 64'h41DF800000003FFF;
+    ReadData2E = 64'h43C00000001FBFFF;
+    ReadData3E = 64'h380FFFFFFFF7F800;
+    ans = 64'h45AF8000003EC1FD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"219401\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'hC01962BD104E333A;
+    ans = 64'hC01962BD104E333A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"219707\n");
+    end
+    ReadData1E = 64'h496FFFFFFF7FF800;
+    ReadData2E = 64'h47E000001FFFFFFF;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'h516000001FBFFBFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"220013\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"220319\n");
+    end
+    ReadData1E = 64'h0ECFFFFFFFFFFFFA;
+    ReadData2E = 64'hC03FFBFFFEFFFFFF;
+    ReadData3E = 64'hC03FFEFBFFFFFFFE;
+    ans = 64'hC03FFEFBFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"220625\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC03FFFFFFFFFFFFF;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'h805EFFFFFFFFFFFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"220931\n");
+    end
+    ReadData1E = 64'h3FF00000040000FE;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'hBCBFEFFFFFFFFFC0;
+    ans = 64'h3FE00000040000FA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"221237\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC3EA4F01DB82E6F6;
+    ReadData3E = 64'hC1D0000000800002;
+    ans = 64'hC1D0000000800002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"221543\n");
+    end
+    ReadData1E = 64'hC975270E98987C51;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'hC965270E98987C50;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"221849\n");
+    end
+    ReadData1E = 64'hC01000000FFFFFFE;
+    ReadData2E = 64'hF6EFFFFFF000FFFF;
+    ReadData3E = 64'h41EFFE0080000000;
+    ans = 64'h7710000008007FF6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"222155\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'h400CCB5237997727;
+    ans = 64'h400CCB5237997727;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"222461\n");
+    end
+    ReadData1E = 64'h43F0040010000000;
+    ReadData2E = 64'h47A1B34990150361;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h4BA1B7B6742C5232;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"222767\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"223073\n");
+    end
+    ReadData1E = 64'h401FFFBFFF7FFFFF;
+    ReadData2E = 64'h3E600000013FFFFF;
+    ReadData3E = 64'hC1F0001040000000;
+    ans = 64'hC1F0001040000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"223379\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h404FF80000000010;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h006FF8000000000C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"223685\n");
+    end
+    ReadData1E = 64'h2F400000000FBFFF;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'h41F606CA2848B3D9;
+    ans = 64'h41F606CA2848B3D9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"223991\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC02FFFFF0001FFFF;
+    ReadData3E = 64'h3E7F00003FFFFFFF;
+    ans = 64'h3E7F00003FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"224297\n");
+    end
+    ReadData1E = 64'h3FEFFEFFE0000000;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'h3FDFFDFFBFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"224603\n");
+    end
+    ReadData1E = 64'h4F0A74F16F87B7F7;
+    ReadData2E = 64'hC3EFDFFFFFFE0000;
+    ReadData3E = 64'hC06BE163A6D740EF;
+    ans = 64'hD30A5A7C7E1688F0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"224909\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBDA00BFFFFFFFFFF;
+    ans = 64'hBDA00BFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"225215\n");
+    end
+    ReadData1E = 64'h480DA52CB9BE1522;
+    ReadData2E = 64'hBFF0000020007FFE;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC80DA52CF5095BBB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"225521\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h3FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"225827\n");
+    end
+    ReadData1E = 64'h24A18A36F18AE59F;
+    ReadData2E = 64'h17C00080000001FE;
+    ReadData3E = 64'h356FFF8002000000;
+    ans = 64'h356FFF8002000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"226133\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h41EFC6443D52B99A;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"226439\n");
+    end
+    ReadData1E = 64'h403BD20E5EDBB48B;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'h8C61D52AFF1B225C;
+    ans = 64'h403BD20E5EDBB48D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"226745\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC07FFFFFFFFFFFDC;
+    ReadData3E = 64'h41301E0000000000;
+    ans = 64'h41301E0000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"227051\n");
+    end
+    ReadData1E = 64'h3922C21DDFDA7C7B;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h3CAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"227357\n");
+    end
+    ReadData1E = 64'h43F00002FFFFFFFE;
+    ReadData2E = 64'hBE5FFFFFFFFFFFFF;
+    ReadData3E = 64'h4E4FFFFF1FFFFFFF;
+    ans = 64'h4E4FFFFF1FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"227663\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h3F2D90DCFD91775A;
+    ans = 64'h3F2D90DCFD91775A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"227969\n");
+    end
+    ReadData1E = 64'hB667FFFFEFFFFFFF;
+    ReadData2E = 64'hBE2003FFF8000000;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'h4000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"228275\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"228581\n");
+    end
+    ReadData1E = 64'h4340020000010000;
+    ReadData2E = 64'h3810000001FFFFEF;
+    ReadData3E = 64'h42BB43994E714E2E;
+    ans = 64'h42BB43994E714E2E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"228887\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h401FFC03FFFFFFFE;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"229193\n");
+    end
+    ReadData1E = 64'h41FFFF7FFFFFFFE0;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'h7300801FFFFFFFFE;
+    ans = 64'h7300801FFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"229499\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC0007FFFFFFFDFFF;
+    ReadData3E = 64'h4C9FFFFDF8000000;
+    ans = 64'h4C9FFFFDF8000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"229805\n");
+    end
+    ReadData1E = 64'h628FFFFBFC000000;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'h629FFFFBFC000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"230111\n");
+    end
+    ReadData1E = 64'hC01F7FFBFFFFFFFE;
+    ReadData2E = 64'hC130010020000000;
+    ReadData3E = 64'h3FBFF7FFFFFFDFFE;
+    ans = 64'h415F81F446BDF7FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"230417\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'hBC7FFFFFFFFF07FF;
+    ans = 64'hBC7FFFFFFFFF07FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"230723\n");
+    end
+    ReadData1E = 64'h3FF0000040000001;
+    ReadData2E = 64'hC02000FFFFFF7FFF;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hC024010040038000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"231029\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h3CAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"231335\n");
+    end
+    ReadData1E = 64'h47EFFFFFFFF7FF7F;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'hC860000010003FFE;
+    ans = 64'hC860000010003FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"231641\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC4DFFFFFFFFFFFC1;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"231947\n");
+    end
+    ReadData1E = 64'h3FFFFF7FFDFFFFFF;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'h47748A41CB17831D;
+    ans = 64'h47748A41CB17831D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"232253\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hB8100000000011FF;
+    ReadData3E = 64'h403FFFFFF87FFFFF;
+    ans = 64'h403FFFFFF87FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"232559\n");
+    end
+    ReadData1E = 64'h3D7D028206CB6C42;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h3D9D028206CB6C44;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"232865\n");
+    end
+    ReadData1E = 64'h41407FFF80000000;
+    ReadData2E = 64'hA640000020000000;
+    ReadData3E = 64'hC3E200000000003E;
+    ans = 64'hC3E200000000003E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"233171\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'h409FFFFFFFFEFFFD;
+    ans = 64'h409FFFFFFFFEFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"233477\n");
+    end
+    ReadData1E = 64'hC7F0004010000000;
+    ReadData2E = 64'h38038FCF6BF4B472;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'hBFF7203B7D846763;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"233783\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hBCA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"234089\n");
+    end
+    ReadData1E = 64'hC07223F0FE41D18A;
+    ReadData2E = 64'hBF90001FFFFFF7FE;
+    ReadData3E = 64'h3D70007FFFFF7FFF;
+    ans = 64'h401224154623C8FA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"234395\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h4319A2C1C0285F37;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h4340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"234701\n");
+    end
+    ReadData1E = 64'hBCAFFFFFFFC01000;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'hC0EFF00FFFFFFFFF;
+    ans = 64'hC0EFF00FFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"235007\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h43400021FFFFFFFF;
+    ReadData3E = 64'h3FCFFFFFFFE00004;
+    ans = 64'h3FCFFFFFFFE00004;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"235313\n");
+    end
+    ReadData1E = 64'hB05FFFDFFFFEFFFF;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'hB3AFFFDFFFFEFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"235619\n");
+    end
+    ReadData1E = 64'h0020000000000807;
+    ReadData2E = 64'h43EFFFEFFFFFFFF0;
+    ReadData3E = 64'h401FFFFFFCFFFFFF;
+    ans = 64'h401FFFFFFCFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"235925\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'h43C0000002000000;
+    ans = 64'h43C0000002000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"236231\n");
+    end
+    ReadData1E = 64'hFFED5680A72E37A2;
+    ReadData2E = 64'h41F6874673086E01;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"236537\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h036FFFFFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"236843\n");
+    end
+    ReadData1E = 64'h47F0001000000000;
+    ReadData2E = 64'h3D00010000000080;
+    ReadData3E = 64'h380A26E8BAE640A4;
+    ans = 64'h4500011001000080;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"237149\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h801B2DC8D53A6A81;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"237455\n");
+    end
+    ReadData1E = 64'h3FD0000000000A00;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'hE25FFFFFFF83FFFE;
+    ans = 64'hE25FFFFFFF83FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"237761\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FDD188A4F128793;
+    ReadData3E = 64'hBFEFFFFFFEDFFFFF;
+    ans = 64'hBFEFFFFFFEDFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"238067\n");
+    end
+    ReadData1E = 64'h7FFFFFE0000FFFFF;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"238373\n");
+    end
+    ReadData1E = 64'hC3EFFFFFFFFFEE00;
+    ReadData2E = 64'hC7F000000000803F;
+    ReadData3E = 64'hC1CFDFBFFFFFFFFF;
+    ans = 64'h4BF000000000773F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"238679\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'h30F5B31E15D86A5A;
+    ans = 64'h3FFFFFFFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"238985\n");
+    end
+    ReadData1E = 64'hDF90800000003FFE;
+    ReadData2E = 64'hD7E1FFFFFFFFFFFE;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h77829000000047FC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"239291\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"239597\n");
+    end
+    ReadData1E = 64'hC08FFFFF00003FFF;
+    ReadData2E = 64'h3FD0080000000004;
+    ReadData3E = 64'hC388EF1792D83470;
+    ans = 64'hC388EF1792D83478;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"239903\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h381000000FFFFF7E;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h400FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"240209\n");
+    end
+    ReadData1E = 64'h403FFFFDFFFFFEFE;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hC00FFBFDFFFFFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"240515\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hEB8FDFBFFFFFFFFF;
+    ReadData3E = 64'hC032000000003FFF;
+    ans = 64'hC032000000003FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"240821\n");
+    end
+    ReadData1E = 64'h37E00100003FFFFF;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"241127\n");
+    end
+    ReadData1E = 64'hBF8CD92404A3E8B5;
+    ReadData2E = 64'hFFE000000FFF7FFF;
+    ReadData3E = 64'h8000102000000000;
+    ans = 64'h7F7CD924217C25EF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"241433\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h4020000010080000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"241739\n");
+    end
+    ReadData1E = 64'hB35FFFEFDFFFFFFE;
+    ReadData2E = 64'hC0900007FFFFBFFE;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hBCAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"242045\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"242351\n");
+    end
+    ReadData1E = 64'hBFE9E4420B1827EE;
+    ReadData2E = 64'hC190000080000002;
+    ReadData3E = 64'hB73C9715382BE1E6;
+    ans = 64'h4189E442DA3A384A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"242657\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h41CAA0EB1CCD7918;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hBFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"242963\n");
+    end
+    ReadData1E = 64'hCC0FFFFFDFFFFFBF;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBE80080000008000;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"243269\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hB980FFFFF7FFFFFE;
+    ReadData3E = 64'hA28FFFFFFF83FFFF;
+    ans = 64'hA28FFFFFFF83FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"243575\n");
+    end
+    ReadData1E = 64'h43FFFF000000001F;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"243881\n");
+    end
+    ReadData1E = 64'h555FFE00000001FF;
+    ReadData2E = 64'h401FFEFFFFFBFFFF;
+    ReadData3E = 64'hC3E6BCB070CDA62F;
+    ans = 64'h558FFD000FFC023E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"244187\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h41F0001000000001;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"244493\n");
+    end
+    ReadData1E = 64'h402FFFFDFFFF7FFE;
+    ReadData2E = 64'h403C63BB8B2B2B77;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h407C63B9C4EF0134;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"244799\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"245105\n");
+    end
+    ReadData1E = 64'hC3CFF7FFFFEFFFFE;
+    ReadData2E = 64'h507000000000101F;
+    ReadData3E = 64'hB8000000000011FF;
+    ans = 64'hD44FF7FFFFF02034;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"245411\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h000FFFFFDFFFFFF0;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h3FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"245717\n");
+    end
+    ReadData1E = 64'h9DF0000002FFFFFE;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'hB72FFFFBFFFFFFFE;
+    ans = 64'hB72FFFFBFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"246023\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hFFDDC2F0D865AC3F;
+    ReadData3E = 64'hBF700000000007FF;
+    ans = 64'hBFFDD2F0D865AC43;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"246329\n");
+    end
+    ReadData1E = 64'hBFBFFFFBFFBFFFFF;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h434FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"246635\n");
+    end
+    ReadData1E = 64'hB32585C41E783BBC;
+    ReadData2E = 64'hC3C0001000000020;
+    ReadData3E = 64'hC74FFFFFEFFFFFF8;
+    ans = 64'hC74FFFFFEFFFFFF8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"246941\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FE285F0E49D4A7B;
+    ans = 64'h7FE285F0E49D4A7B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"247247\n");
+    end
+    ReadData1E = 64'hC3500100000FFFFF;
+    ReadData2E = 64'hBDF0E1E8C66ADBAB;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h4150E2F6E5082440;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"247553\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"247859\n");
+    end
+    ReadData1E = 64'h3F700007FFFEFFFE;
+    ReadData2E = 64'hB7FC3FB36C2D5B84;
+    ReadData3E = 64'hBFFFFBFFFFFFF7FF;
+    ans = 64'hBFFFFBFFFFFFF7FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"248165\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3F97A677C36D84B9;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'hBFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"248471\n");
+    end
+    ReadData1E = 64'h401537E560C75BAB;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'h3FB0000007FFFFEF;
+    ans = 64'h3FB0000007FFFFEF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"248777\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h406FFFBFFFFFF7FF;
+    ReadData3E = 64'h403FE000000FFFFF;
+    ans = 64'h403FE000000FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"249083\n");
+    end
+    ReadData1E = 64'hC00000080000000E;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hC01FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"249389\n");
+    end
+    ReadData1E = 64'hBF9F2337AA50C4F6;
+    ReadData2E = 64'h41FFFBFFFFFFFFF0;
+    ReadData3E = 64'hC0BFFFFFDFFFFFBF;
+    ans = 64'hC1AF1F93435B3ACE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"249695\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'hC3EE512EE6662CCD;
+    ans = 64'hC3EE512EE6662CCD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"250001\n");
+    end
+    ReadData1E = 64'hDA1FE00000040000;
+    ReadData2E = 64'h40301FFFFFFFFFDF;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'hDA600FE0000203DF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"250307\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h434FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"250613\n");
+    end
+    ReadData1E = 64'hC00FFFCFFFFFFFFF;
+    ReadData2E = 64'hE97E000000800000;
+    ReadData3E = 64'hBFEFFFFFF7FFF800;
+    ans = 64'h699DFFD3007FFF3F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"250919\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBCAFFF7FFF800000;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h3FDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"251225\n");
+    end
+    ReadData1E = 64'hC02000000400001E;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'hB80FFFFC0000001F;
+    ans = 64'h3CD000000400001E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"251531\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC0A0004001FFFFFF;
+    ReadData3E = 64'hC28F000000000100;
+    ans = 64'hC28F000000000100;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"251837\n");
+    end
+    ReadData1E = 64'hC06292D76228137B;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000013;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"252143\n");
+    end
+    ReadData1E = 64'h3CA80000000000FE;
+    ReadData2E = 64'h8017FB4D2CCAA271;
+    ReadData3E = 64'h3F6000000010000F;
+    ans = 64'h3F6000000010000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"252449\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'hBE11E49856E4D7E0;
+    ans = 64'hBE11E49856E4D7E0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"252755\n");
+    end
+    ReadData1E = 64'hC3FBFFFEFFFFFFFE;
+    ReadData2E = 64'hBFF0007FFFC00000;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"253061\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hC01FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"253367\n");
+    end
+    ReadData1E = 64'hC80EF613678AF683;
+    ReadData2E = 64'hCD8172A803FEC66C;
+    ReadData3E = 64'hC7EFFFFFFFFF8020;
+    ans = 64'h55A0E1A983E624A4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"253673\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBF1291958811E1EE;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hBCAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"253979\n");
+    end
+    ReadData1E = 64'hCABFFF0000003FFF;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'h002FFFFFBFFFFFFC;
+    ans = 64'h4A9FFF0000003FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"254285\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h6E3ABB40B7437E23;
+    ReadData3E = 64'hCB5F39111E61024E;
+    ans = 64'hCB5F39111E61024E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"254591\n");
+    end
+    ReadData1E = 64'hBCA100000000FFFE;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"254897\n");
+    end
+    ReadData1E = 64'hE3F00000001FBFFF;
+    ReadData2E = 64'h4800FFFFFFFFFF7F;
+    ReadData3E = 64'h0132E73035E25848;
+    ans = 64'hEC0100000021BB7E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"255203\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'hB6B662EDDC60BE5B;
+    ans = 64'hB6B662EDDC60BE5B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"255509\n");
+    end
+    ReadData1E = 64'hBF879A0574BE9D7E;
+    ReadData2E = 64'h3FE5C6796BC3A859;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"255815\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"256121\n");
+    end
+    ReadData1E = 64'h3FC623839C67FBA6;
+    ReadData2E = 64'h5FC855109CEE8C4A;
+    ReadData3E = 64'hE8F0003FFFF00000;
+    ans = 64'hE8F0003FFFF00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"256427\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h002493107A4421CE;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h3CA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"256733\n");
+    end
+    ReadData1E = 64'hC02FFFFFE01FFFFF;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'h4DA0003FFFFFDFFF;
+    ans = 64'h4DA0003FFFFFDFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"257039\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FEE00007FFFFFFF;
+    ReadData3E = 64'h001E4E082A17FB0B;
+    ans = 64'h0026A704350BFD84;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"257345\n");
+    end
+    ReadData1E = 64'hA240000000004000;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
     ans = 64'h3FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"257651\n");
+    end
+    ReadData1E = 64'h41B0000000000006;
+    ReadData2E = 64'hC7EFF7FFFFFEFFFF;
+    ReadData3E = 64'hB8139885504DA644;
+    ans = 64'hC9AFF7FFFFFF000B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"257957\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'hBDBBFFFFFFFFF7FE;
+    ans = 64'hBDBBFFFFFFFFF7FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"258263\n");
+    end
+    ReadData1E = 64'h3FB0FFFFFFFFFEFF;
+    ReadData2E = 64'h37E0000000001FFD;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"258569\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"258875\n");
+    end
+    ReadData1E = 64'h223E000000000007;
+    ReadData2E = 64'hC020000003FFFFBE;
+    ReadData3E = 64'h3F3FFFFFFE010000;
+    ans = 64'h3F3FFFFFFE010000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"259181\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FFFFFFFEFF7FFFF;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h000FFFFFEFF7FFFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"259487\n");
+    end
+    ReadData1E = 64'h403FFFFFFEE00000;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FEFDFFFF7FFFFFF;
+    ans = 64'h7FEFDFFFF7FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"259793\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h7FEA683B1EC46B7D;
+    ReadData3E = 64'h37EF003FFFFFFFFF;
+    ans = 64'h400A683B1EC46B7A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"260099\n");
+    end
+    ReadData1E = 64'h4000000000200002;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hC008000000200000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"260405\n");
+    end
+    ReadData1E = 64'hC03FFFC000000007;
+    ReadData2E = 64'hC3C000FFFDFFFFFF;
+    ReadData3E = 64'h3FE800000FFFFFFE;
+    ans = 64'h441000DFFC000403;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"260711\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'hC3FE00FFFFFFFFFF;
+    ans = 64'hC3FE00FFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"261017\n");
+    end
+    ReadData1E = 64'hDC70000010020000;
+    ReadData2E = 64'h40900D506FFEE146;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hDD100D50800E3360;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"261323\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h3FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"261629\n");
+    end
+    ReadData1E = 64'h5DA000FFFFFFFFFF;
+    ReadData2E = 64'hBFE0080000000004;
+    ReadData3E = 64'hBFF07FFFFFBFFFFF;
+    ans = 64'hDD90090080000003;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"261935\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h401FFFFFF0000400;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h0041FFFFF80001FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"262241\n");
+    end
+    ReadData1E = 64'h412007FFFEFFFFFF;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h4012000040000000;
+    ans = 64'hC13007FB7EFFEFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"262547\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h4380000000100003;
+    ReadData3E = 64'hD43000000FFFFF7F;
+    ans = 64'hD43000000FFFFF7F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"262853\n");
+    end
+    ReadData1E = 64'hC03C5E2AE452C6D3;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h404C9E2AE452C6D1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"263159\n");
+    end
+    ReadData1E = 64'hC3DFAF53AFB9F351;
+    ReadData2E = 64'hBFAFF8000000FFFF;
+    ReadData3E = 64'h43CAD1C87055F27F;
+    ans = 64'h43CEC6B56BAFD2C9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"263465\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC7E4008000000000;
+    ans = 64'hC7E4008000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"263771\n");
+    end
+    ReadData1E = 64'h4033C0DD77566DA9;
+    ReadData2E = 64'h47E001FFFFFFFE00;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h4823C355930555FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"264077\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hBFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"264383\n");
+    end
+    ReadData1E = 64'hBFC5C91E28AE3927;
+    ReadData2E = 64'h800FDFFFFFFFFFFE;
+    ReadData3E = 64'hC90FFF00003FFFFE;
+    ans = 64'hC90FFF00003FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"264689\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FB000000000401F;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"264995\n");
+    end
+    ReadData1E = 64'h47F0007FFE000000;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'h41EAF62DF12D1A41;
+    ans = 64'hC800007FFE000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"265301\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFDFFFFFFE00003F;
+    ReadData3E = 64'h41FFF7FFFFFC0000;
+    ans = 64'h41FFF7FFFFFC0000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"265607\n");
+    end
+    ReadData1E = 64'h2FC0000800001FFF;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hBFD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"265913\n");
+    end
+    ReadData1E = 64'h380AEFDDEF1C3975;
+    ReadData2E = 64'h4013173BC23790A3;
+    ReadData3E = 64'h43CFC000000003FF;
+    ans = 64'h43CFC000000003FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"266219\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'h408000FFFFFFFFF8;
+    ans = 64'h408000FFFFFFFFF8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"266525\n");
+    end
+    ReadData1E = 64'hB9FF000000020000;
+    ReadData2E = 64'hC03DDB784BF264CB;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hC00FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"266831\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h3FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"267137\n");
+    end
+    ReadData1E = 64'hC1E444153B5F480B;
+    ReadData2E = 64'h437CF734BD2A8438;
+    ReadData3E = 64'hC88CB6C24967E7EC;
+    ans = 64'hC88CB6C24967E7F5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"267443\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC1FC000000080000;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"267749\n");
+    end
+    ReadData1E = 64'hBFFFFFFF7FFFFF7F;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'hC3F000000400FFFE;
+    ans = 64'hC3F000000400FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"268055\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h48B0715E3CE4DAB7;
+    ReadData3E = 64'h41E00000000000DF;
+    ans = 64'h41E00000000000DF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"268361\n");
+    end
+    ReadData1E = 64'h4EB0FFFFFFFFFF80;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'hCEE0FFFFFFFFFF7F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"268667\n");
+    end
+    ReadData1E = 64'h37FFFFFEEFFFFFFF;
+    ReadData2E = 64'h802FFE00003FFFFE;
+    ReadData3E = 64'hBFE9184238350997;
+    ans = 64'hBFE9184238350997;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"268973\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'h43CFCA9038906DA8;
+    ans = 64'h43CFCA9038906DA8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"269279\n");
+    end
+    ReadData1E = 64'hBFDFFFFFF7FFE000;
+    ReadData2E = 64'h5EC0000000002FFF;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'hDEAFFFFFF8003FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"269585\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hBFD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"269891\n");
+    end
+    ReadData1E = 64'h43EFFFFFFFFC007E;
+    ReadData2E = 64'h1B1FFBFFFFC00000;
+    ReadData3E = 64'hC7E080000000003F;
+    ans = 64'hC7E080000000003F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"270197\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFCDD72B2723C364;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"270503\n");
+    end
+    ReadData1E = 64'hC80FFFFEF0000000;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'hC01FFFFFFFF80007;
+    ans = 64'h4B5FFFFEF0000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"270809\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h47E0000000403FFF;
+    ReadData3E = 64'h4010F3DB191A1F8F;
+    ans = 64'h4010F3DB191A1F8F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"271115\n");
+    end
+    ReadData1E = 64'h401FFFFC0007FFFF;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'hC36FFFFC00080001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"271421\n");
+    end
+    ReadData1E = 64'h3FFFD00A729C4742;
+    ReadData2E = 64'hC3CFFFFFFF1FFFFE;
+    ReadData3E = 64'h3FC000000000BFFE;
+    ans = 64'hC3DFD00A71BD96F7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"271727\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'h43D5B0920D1BF88E;
+    ans = 64'h43D5B0920D1BF88E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"272033\n");
+    end
+    ReadData1E = 64'h3CA27282D68BAADA;
+    ReadData2E = 64'h400FFFF80003FFFF;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hBFEFFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"272339\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'h3CAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"272645\n");
+    end
+    ReadData1E = 64'h5F901FFFFFFFFFFE;
+    ReadData2E = 64'h47EFFF000000FFFF;
+    ReadData3E = 64'hBFDFFFFFF7FFFFFB;
+    ans = 64'h67901F7F000080FD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"272951\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h657FFFFFFFFBFFF6;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"273257\n");
+    end
+    ReadData1E = 64'hC0300FFFFFFFFEFF;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'hC004003FFFFFFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"273563\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h43E1AA2F8A851184;
+    ReadData3E = 64'hB8000000007FFFFD;
+    ans = 64'hB8000000007FFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"273869\n");
+    end
+    ReadData1E = 64'h3F8FFFFDFFFFFE00;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'hFF7FFFFDFFFFFE02;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"274175\n");
+    end
+    ReadData1E = 64'hB7EFFF00000001FE;
+    ReadData2E = 64'h77CFFFFFFFE10000;
+    ReadData3E = 64'hA3A0000000007FBF;
+    ans = 64'hEFCFFEFFFFE102F6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"274481\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hB93E92AC23EB1A80;
+    ans = 64'hBFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"274787\n");
+    end
+    ReadData1E = 64'h3E2FFFFF00001FFF;
+    ReadData2E = 64'h41E8C14DBD3E8F88;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h402AC14CF7343A5F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"275093\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'hC00FFFFFFFFFFFFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"275399\n");
+    end
+    ReadData1E = 64'h41C010000007FFFF;
+    ReadData2E = 64'hC03FFE000000007E;
+    ReadData3E = 64'hBFF0001FFFFFFFF7;
+    ans = 64'hC2100EFF000BFFC6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"275705\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h1487869849373A4D;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h401FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"276011\n");
+    end
+    ReadData1E = 64'hC2780000000007FF;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hC18FFC0000000004;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"276317\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h41758A7AFB86E8EF;
+    ReadData3E = 64'h402C084092D67AFA;
+    ans = 64'h402C084092D67AFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"276623\n");
+    end
+    ReadData1E = 64'h41CFFDFFFFFFFFFF;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"276929\n");
+    end
+    ReadData1E = 64'hC7E14E030C337810;
+    ReadData2E = 64'hB4508B55779CF496;
+    ReadData3E = 64'h418FFFF00003FFFE;
+    ans = 64'h418FFFF00003FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"277235\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'h78EFFFFFFF7F7FFF;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"277541\n");
+    end
+    ReadData1E = 64'hB8100800007FFFFF;
+    ReadData2E = 64'h421BC643D44ACF51;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"277847\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"278153\n");
+    end
+    ReadData1E = 64'h57F0400000000003;
+    ReadData2E = 64'h3FEFF800000003FF;
+    ReadData3E = 64'h3FDFFFFFFEFE0000;
+    ans = 64'h57F03BF00000020A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"278459\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h4340007FFFFFFFEE;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"278765\n");
+    end
+    ReadData1E = 64'h33D0000003FE0000;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FCFDFFFFFFDFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"279071\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFFFFE;
+    ReadData2E = 64'h401000000000207F;
+    ReadData3E = 64'hBFEFF7FFFFFFFFFF;
+    ans = 64'hBFEFF7FFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"279377\n");
+    end
+    ReadData1E = 64'h3EDFFF7BFFFFFFFF;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"279683\n");
+    end
+    ReadData1E = 64'hBFF007FFFFFFBFFF;
+    ReadData2E = 64'hABFFFE00FFFFFFFE;
+    ReadData3E = 64'h3FFFFFFFFFFFFBFB;
+    ans = 64'h3FFFFFFFFFFFFBFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"279989\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'h7FDFFFFFC0001000;
+    ans = 64'h7FDFFFFFC0001000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"280295\n");
+    end
+    ReadData1E = 64'h401E7FA35DDC0D0A;
+    ReadData2E = 64'hBFE0000400000040;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'hC00C7FAAFDC4E4FB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"280601\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h8000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"280907\n");
+    end
+    ReadData1E = 64'hD1925886906206D4;
+    ReadData2E = 64'hC1E8EAED66B2863A;
+    ReadData3E = 64'hC0202003FFFFFFFF;
+    ans = 64'h538C9228BD9CEB27;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"281213\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC3F00000203FFFFE;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'h4000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"281519\n");
+    end
+    ReadData1E = 64'h3FEFFFFF5FFFFFFF;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'h4029E3589C74D6C1;
+    ans = 64'h4029E3589C74D6C1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
@@ -21612,7189 +35947,11971 @@ initial
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
     	$fwrite(fp,"281825\n");
     end
-    x = 64'h7260001FFF7FFFFF;
-    y = 64'h376FEBC83323C3E3;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h69DFEC0809B4CBE7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h4755B660F1AE640B;
+    ReadData3E = 64'h3790000000001BFE;
+    ans = 64'h3790000000001BFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"282439\n");
+    	$fwrite(fp,"282131\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h0010000000000000;
-    z = 64'hBC555EBEF2DFDF4F;
-    ans = 64'hBC555EBEF2DFDF4F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h380FF00FFFFFFFFF;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"283053\n");
+    	$fwrite(fp,"282437\n");
     end
-    x = 64'hB9AFFFFFFEFFFFEF;
-    y = 64'hB8001FF800000000;
-    z = 64'h369A9A31438FD892;
-    ans = 64'h369A9A31438FD892;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFE200000000FFFE;
+    ReadData2E = 64'h41FD6E4653630B63;
+    ReadData3E = 64'h480FFFF008000000;
+    ans = 64'h480FFFF008000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"283667\n");
+    	$fwrite(fp,"282743\n");
     end
-    x = 64'hF0DFFF800000FFFF;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'hC3E000000002003E;
+    ans = 64'hC3E000000002003E;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"284281\n");
+    	$fwrite(fp,"283049\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'hA10FFFFFFFFFFFFF;
-    z = 64'hC1F312A8C47A6E98;
-    ans = 64'hC1F312A8C47A6E98;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC020000400000004;
+    ReadData2E = 64'h41064F83F491A335;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hC1364F898872A05F;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"284895\n");
+    	$fwrite(fp,"283355\n");
     end
-    x = 64'h3CAFFFFB00000000;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hBEAFFFDFFFFFFFFC;
-    ans = 64'hBEAFFFDFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"285509\n");
+    	$fwrite(fp,"283661\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'hB80FFFC000000100;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFE5000000000000;
+    ReadData2E = 64'hB49FEFFEFFFFFFFE;
+    ReadData3E = 64'hC1CFDFFFFFF7FFFE;
+    ans = 64'hC1CFDFFFFFF7FFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"286123\n");
+    	$fwrite(fp,"283967\n");
     end
-    x = 64'hC3FFFFFFBFFF7FFF;
-    y = 64'hBF6200001FFFFFFE;
-    z = 64'hC0300000001FF7FF;
-    ans = 64'h4371FFFFFBFFB7BC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3FF1FFFFFFBFFFFF;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hBFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"286737\n");
+    	$fwrite(fp,"284273\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFE;
+    ReadData1E = 64'hC16000000000021E;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'h41C0000000000100;
+    ans = 64'h41C0000000000100;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"284579\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC1D022D17DB65925;
+    ReadData3E = 64'h7FDE0000FFFFFFFF;
+    ans = 64'h7FDE0000FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"284885\n");
+    end
+    ReadData1E = 64'h3FDE0001FFFFFFFE;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"285191\n");
+    end
+    ReadData1E = 64'hC7FFC00000003FFF;
+    ReadData2E = 64'h3D20000000021FFE;
+    ReadData3E = 64'h2EEFFFFFFFFF6FFE;
+    ans = 64'hC52FC0000004777B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"285497\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'hC1F0007DFFFFFFFE;
+    ans = 64'hC1F0007DFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"285803\n");
+    end
+    ReadData1E = 64'hC173218EED2EAD60;
+    ReadData2E = 64'hC620000040000080;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h47A3218F39B4E9AE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"286109\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"286415\n");
+    end
+    ReadData1E = 64'hC2A902A218479D05;
+    ReadData2E = 64'hA0BFFFE020000000;
+    ReadData3E = 64'h41DBFFFFFFFEFFFF;
+    ans = 64'h41DBFFFFFFFEFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"286721\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h42F07DEEE25F8464;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
     ans = 64'h3FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"287351\n");
+    	$fwrite(fp,"287027\n");
     end
-    x = 64'hB54FFFF81FFFFFFF;
-    y = 64'h41C5D768F450EFAD;
-    z = 64'h0000000000000000;
-    ans = 64'hB725D763944E1B8C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC160000042000000;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h4013FFFFFFFFFFFF;
+    ans = 64'h4013FFFFFFEFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"287965\n");
+    	$fwrite(fp,"287333\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h43DBFFFFFFFFE000;
-    ans = 64'h43DBFFFFFFFFE000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC16FFFDFFFFF7FFE;
+    ReadData3E = 64'hC7FFFFFFF7FFFFFF;
+    ans = 64'hC7FFFFFFF7FFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"288579\n");
+    	$fwrite(fp,"287639\n");
     end
-    x = 64'hC3FFDFF7FFFFFFFF;
-    y = 64'hC139FA0B752F76EF;
-    z = 64'hBFCFFFDFFFFFF800;
-    ans = 64'h4549E00AEB376A2B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h7FD000000BFFFFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h7C9000000BFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"289193\n");
+    	$fwrite(fp,"287945\n");
     end
-    x = 64'h7783F12BB577FCCF;
-    y = 64'h3FD0000000000001;
-    z = 64'h4010000000000000;
-    ans = 64'h7763F12BB577FCD0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFD0000010000008;
+    ReadData2E = 64'hC1EFFFFFFBFFFFFD;
+    ReadData3E = 64'h49600000001BFFFF;
+    ans = 64'h49600000001BFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"289807\n");
+    	$fwrite(fp,"288251\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h380E895E8EC54D4B;
-    z = 64'hC34000000807FFFF;
-    ans = 64'hC34000000807FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFF003FC00000000;
+    ans = 64'hFFF803FC00000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"290421\n");
+    	$fwrite(fp,"288557\n");
     end
-    x = 64'h517A65ACF3CF57EB;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h80100007FFFFFFFF;
-    ans = 64'h516A65ACF3CF57EA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC06FDFBFFFFFFFFE;
+    ReadData2E = 64'h002000011FFFFFFF;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h809FEFC23DBB7FFC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"291035\n");
+    	$fwrite(fp,"288863\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h358FFFF000003FFF;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"291649\n");
+    	$fwrite(fp,"289169\n");
     end
-    x = 64'hB81628C1870235BB;
-    y = 64'h429AEA3DE2F34B36;
-    z = 64'h5DBFFFFFFFFEDFFF;
-    ans = 64'h5DBFFFFFFFFEDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h842FFFFFFFFEFFFC;
+    ReadData2E = 64'hFFFFFFDFFFFFFFFD;
+    ReadData3E = 64'h1E80000200000010;
+    ans = 64'hFFFFFFDFFFFFFFFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"292263\n");
+    	$fwrite(fp,"289475\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h3FE0000000000001;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h9590000001F7FFFF;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hBFE0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"292877\n");
+    	$fwrite(fp,"289781\n");
     end
-    x = 64'hBF4A92FFF1A2C1E7;
-    y = 64'hFFFFFFFFFFFE007F;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFFFFFFFFFFE007F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h62DE00000007FFFF;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'h3FEFFFFBFFFFDFFF;
+    ans = 64'h62BE000000080001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"293491\n");
+    	$fwrite(fp,"290087\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h3FCFFFFFFFFFE7FE;
-    ans = 64'h3FCFFFFFFFFFE7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h41E0000000200007;
+    ReadData3E = 64'h414302D9B4ED0185;
+    ans = 64'h414302D9B4ED0185;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"294105\n");
+    	$fwrite(fp,"290393\n");
     end
-    x = 64'hBFC000FFFFFFFFEE;
-    y = 64'h3F5FEB520191C6A8;
-    z = 64'hC010FFFFFFFFFFE0;
-    ans = 64'hC011003FDAA16D44;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB7F0FFFFFF7FFFFE;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"294719\n");
+    	$fwrite(fp,"290699\n");
     end
-    x = 64'h401040000000000E;
-    y = 64'h3FF0000000000000;
-    z = 64'h4000000000000001;
-    ans = 64'h401840000000000E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFFE0FFFFFFFFFFF;
+    ReadData2E = 64'hBD203FFFFFFFF800;
+    ReadData3E = 64'hC311550C9132B40C;
+    ans = 64'hC311550C9132B40C;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"295333\n");
+    	$fwrite(fp,"291005\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'hC7E0000020FFFFFF;
-    z = 64'hC0348B6B6CA03F9F;
-    ans = 64'hC0348B6B6CA03F9F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'hC3DFFFF7FFFFC000;
+    ans = 64'hC3DFFFF7FFFFC000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"295947\n");
+    	$fwrite(fp,"291311\n");
     end
-    x = 64'hC3D00021FFFFFFFF;
-    y = 64'h3FF0000000000001;
-    z = 64'hC2BFFFFFFFFFFFFE;
-    ans = 64'hC3D0002A00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFE000007FFFFFFA;
+    ReadData2E = 64'h3FB3EB2F6685C313;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'hFFA3EB3005DF3E40;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"296561\n");
+    	$fwrite(fp,"291617\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'hC1D0020100000000;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"297175\n");
+    	$fwrite(fp,"291923\n");
     end
-    x = 64'h3FB003FFFFFFFFBE;
-    y = 64'hC7F5193A2A17F102;
-    z = 64'hCEAF8FFFFFFFFFFF;
-    ans = 64'hCEAF8FFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB8E701B553E06384;
+    ReadData2E = 64'h001000FFFFFFFFFB;
+    ReadData3E = 64'hBF9FFFFFFFFFDF80;
+    ans = 64'hBF9FFFFFFFFFDF80;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"297789\n");
+    	$fwrite(fp,"292229\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h4000000000000000;
-    z = 64'h3FD0000000000001;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3AEFFFFFFFFFBEFF;
+    ReadData3E = 64'h3FD0000000000001;
     ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"298403\n");
+    	$fwrite(fp,"292535\n");
     end
-    x = 64'hBE4FFFFFFFC80000;
-    y = 64'hB80B00BB0700EEC9;
-    z = 64'hFFEFFFFFFFFFFFFF;
+    ReadData1E = 64'hC7EFF7FFFDFFFFFF;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'h45BFFFFFF7FFFE00;
+    ans = 64'hC7DFF7FFFDF7FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"292841\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h41DFFFF3FFFFFFFE;
+    ReadData3E = 64'hC0100000BFFFFFFF;
+    ans = 64'hC0100000BFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"293147\n");
+    end
+    ReadData1E = 64'h319000080000000F;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h400FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"293453\n");
+    end
+    ReadData1E = 64'h37EFFFFFFFFF0FFF;
+    ReadData2E = 64'h429FFC0003FFFFFF;
+    ReadData3E = 64'h41CFFFF3FFFFFFFF;
+    ans = 64'h41CFFFF3FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"293759\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hF2600100000FFFFE;
+    ans = 64'hF2600100000FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"294065\n");
+    end
+    ReadData1E = 64'h43403FFFFFFFDFFF;
+    ReadData2E = 64'h3F900001EFFFFFFF;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"294371\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"294677\n");
+    end
+    ReadData1E = 64'hDFC0000000040000;
+    ReadData2E = 64'h380E000000000007;
+    ReadData3E = 64'h434FF7FFFEFFFFFF;
+    ans = 64'hD7DE000000078007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"294983\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3FD744F5F33CC055;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hBCAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"295289\n");
+    end
+    ReadData1E = 64'hC7E6D8109ACDBE41;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'hC02DFFBFFFFFFFFF;
+    ans = 64'hC7E6D8109ACDBE41;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"295595\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC020001003FFFFFF;
+    ReadData3E = 64'hC050003F7FFFFFFE;
+    ans = 64'hC050003F7FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"295901\n");
+    end
+    ReadData1E = 64'h434FFBFFFFFFFFE0;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'h434FFBFFFFFFFFDF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"296207\n");
+    end
+    ReadData1E = 64'hC6E0001FFFFFDFFE;
+    ReadData2E = 64'hC036D93D56E70AAC;
+    ReadData3E = 64'h439FFFFFF0000003;
+    ans = 64'h4726D96B09618AC5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"296513\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'hBFB00007FFFFFFFB;
+    ans = 64'hBFB00007FFFFFFFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"296819\n");
+    end
+    ReadData1E = 64'h4025AAF27EF72E72;
+    ReadData2E = 64'h206B033642E4A6A9;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
     ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"299017\n");
+    	$fwrite(fp,"297125\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h4000000000000001;
-    z = 64'h43DE9338EEC9F034;
-    ans = 64'h43DE9338EEC9F034;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h400FFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"299631\n");
+    	$fwrite(fp,"297431\n");
     end
-    x = 64'h47EA1AD664E290AD;
-    y = 64'h9228D0339D8A672A;
-    z = 64'hBB500FFFFFFFFFFA;
-    ans = 64'hBB500FFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h938020FFFFFFFFFF;
+    ReadData2E = 64'h001AFF91BAC0C01C;
+    ReadData3E = 64'h3FA9ED8FA7758F35;
+    ans = 64'h3FA9ED8FA7758F35;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"300245\n");
+    	$fwrite(fp,"297737\n");
     end
-    x = 64'h47EFFFFFFFFE4000;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h480FFFFFFFFE3FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC000000000001080;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h8000000000002102;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"300859\n");
+    	$fwrite(fp,"298043\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h473C6A26FC8DE596;
-    z = 64'h3440003FFFFFFFF6;
-    ans = 64'h3440003FFFFFFFF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h402311AC49E54B80;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hBEE0100000000002;
+    ans = 64'h403311ABC9654B7F;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"301473\n");
+    	$fwrite(fp,"298349\n");
     end
-    x = 64'hC7FBFFFFFFFFFE00;
-    y = 64'h4010000000000000;
-    z = 64'h3FC0000000000202;
-    ans = 64'hC81BFFFFFFFFFE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBFF3FFFFDFFFFFFF;
+    ReadData3E = 64'hB81081FFFFFFFFFE;
+    ans = 64'hB81081FFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"302087\n");
+    	$fwrite(fp,"298655\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'hC7EFFFFFFF700000;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h880FFFFFFF700000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h43FFFFFF7FFFF000;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h440FFFFF7FFFF000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"302701\n");
+    	$fwrite(fp,"298961\n");
     end
-    x = 64'hBA24007FFFFFFFFF;
-    y = 64'hBFB0000008000002;
-    z = 64'hBC2000000800007E;
-    ans = 64'hBC20000007FEC076;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h002632D8A1656279;
+    ReadData2E = 64'hC12BFFFFDFFFFFFE;
+    ReadData3E = 64'h7BF57EED210A57A2;
+    ans = 64'h7BF57EED210A57A2;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"303315\n");
+    	$fwrite(fp,"299267\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'h40B1000003FFFFFE;
+    ans = 64'h40B1000003FFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"303929\n");
+    	$fwrite(fp,"299573\n");
     end
-    x = 64'hB7F02000000FFFFF;
-    y = 64'hBEBC2752FF417189;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h7FF0200000001FFF;
+    ReadData2E = 64'h400FEFFFFFFFE000;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h7FF8200000001FFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"304543\n");
+    	$fwrite(fp,"299879\n");
     end
-    x = 64'h0010000000000000;
-    y = 64'h4340000000000000;
-    z = 64'h403FFFF007FFFFFF;
-    ans = 64'h403FFFF007FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"305157\n");
-    end
-    x = 64'h380FFFF0001FFFFE;
-    y = 64'hBFA4BF5ED9CE8C8E;
-    z = 64'h3FF01000001FFFFF;
-    ans = 64'h3FF01000001FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"305771\n");
-    end
-    x = 64'h3FC001FFFFFFFF7F;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h432001FFFFFFFF80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"306385\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hC7F686065D1D267B;
-    z = 64'h800001000000FFFF;
-    ans = 64'h881686065D1D267B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"306999\n");
-    end
-    x = 64'h43D0000080000000;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h6010007FFFFFFC00;
-    ans = 64'h6010007FFFFFFC00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"307613\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hBF4FDFFFFFF7FFFE;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h801003FBFFFFFEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"308227\n");
-    end
-    x = 64'hC3E4FFFFFFFFFFFE;
-    y = 64'hC0600002000003FF;
-    z = 64'h400F7FFFFFFFFE00;
-    ans = 64'h44550002A000053D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"308841\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"309455\n");
-    end
-    x = 64'hBFF0000040100000;
-    y = 64'hBFF0008000007FFF;
-    z = 64'hC340000000000000;
-    ans = 64'hC33FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"310069\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hC7F0000FFF7FFFFE;
-    ans = 64'hC7F0000FFF7FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"310683\n");
-    end
-    x = 64'hC1DFFFFFFFC0FFFF;
-    y = 64'h381FFFDFFFFF0000;
-    z = 64'hBFD2988A0956184C;
-    ans = 64'hBFD2988A0956184C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"311297\n");
-    end
-    x = 64'hC01FFFFFEFFEFFFE;
-    y = 64'h7FF0000000000001;
-    z = 64'h3FE0000000000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"311911\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hBCA842CEA622C954;
-    z = 64'hFFD001FFFFFFEFFF;
-    ans = 64'hFFD001FFFFFFEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"312525\n");
-    end
-    x = 64'h402080003FFFFFFE;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h801F58D78CAAC986;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"313139\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hBE6FFFFFBFFFFFF7;
-    z = 64'h8000000000000000;
-    ans = 64'h800000000FFFFFE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"313753\n");
-    end
-    x = 64'hBF7804A41F298DA7;
-    y = 64'hBFBD9545159D35EC;
-    z = 64'h37EFF807FFFFFFFE;
-    ans = 64'h3F46343E32A9AFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"314367\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'h8000000000000001;
-    z = 64'h0010000000000000;
-    ans = 64'h0010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"314981\n");
-    end
-    x = 64'h3C1FF7FFFFF7FFFF;
-    y = 64'hBF60040000080000;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"315595\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h47F0000FFFFFFBFF;
-    ans = 64'h47F0000FFFFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"316209\n");
-    end
-    x = 64'hC3DE5E4460AC38DB;
-    y = 64'h400FFFFDFFFFF000;
-    z = 64'h7FEFFFFFFC00000F;
-    ans = 64'h7FEFFFFFFC00000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"316823\n");
-    end
-    x = 64'hC35F7FFFF8000000;
-    y = 64'h8010000000000000;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"317437\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hFFF0000007FFFF00;
-    z = 64'h508FFFFFFFFFE3FF;
-    ans = 64'hFFF8000007FFFF00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"318051\n");
-    end
-    x = 64'h3065CB9EE72E8EAA;
-    y = 64'h8010000000000001;
-    z = 64'hC3F0000200000000;
-    ans = 64'hC3F0000200000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"318665\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'h3FF080000000007F;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"319279\n");
-    end
-    x = 64'h3F20000FFFFFFFBF;
-    y = 64'hBFFE378573394127;
-    z = 64'hC0603FC8BEC02138;
-    ans = 64'hC0603FCAA23A5BE4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"319893\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hBCA0000000000000;
-    z = 64'h0000000000000001;
-    ans = 64'h0000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"320507\n");
-    end
-    x = 64'hE8400000047FFFFE;
-    y = 64'hFFD000100000001F;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"321121\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hBCA0000000000001;
-    z = 64'h2CBFFFF00FFFFFFF;
-    ans = 64'h2CBFFFF00FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"321735\n");
-    end
-    x = 64'h401FFFFFFFFC3FFE;
-    y = 64'h43F0008FFFFFFFFE;
-    z = 64'hC3F2001000000000;
-    ans = 64'h441B811BFFFC3FD8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"322349\n");
-    end
-    x = 64'h1D300047FFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"322963\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'h41C0020000000007;
-    z = 64'h43F4002000000000;
-    ans = 64'h43F4002000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"323577\n");
-    end
-    x = 64'h43C00000FFFEFFFF;
-    y = 64'hBFD0000000000000;
-    z = 64'h3E800FFFFFEFFFFE;
-    ans = 64'hC3A00000FFFEFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"324191\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'h3FDFFFFFFFFFF7FC;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"324805\n");
-    end
-    x = 64'hC04D419BE71CFD22;
-    y = 64'hC05FFFDFFFF7FFFF;
-    z = 64'hBCAB975B5FA2B241;
-    ans = 64'h40BD417EA579C59D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"325419\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"326033\n");
-    end
-    x = 64'hBFCEFFFFFFFFFFBF;
-    y = 64'hC03FFFFFFFFFFFE7;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'h4016FFFFFFFFFFA7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"326647\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hBFE0000000000000;
-    z = 64'hB76FFFFFFFDFFFDE;
-    ans = 64'hB76FFFFFFFDFFFDE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"327261\n");
-    end
-    x = 64'hFFEB046129238D38;
-    y = 64'h491FFFFBEFFFFFFF;
-    z = 64'h406FEDFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"327875\n");
-    end
-    x = 64'hE900000000040003;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h6900000000040002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"328489\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hBFEFF000003FFFFF;
-    z = 64'hC80FFFFFFFFFBFEF;
-    ans = 64'hC80FFFFFFFFFBFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"329103\n");
-    end
-    x = 64'h8001FFFFFFFFDFFF;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hC07FFFFFFF01FFFE;
-    ans = 64'hC07FFFFFFF01FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"329717\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'h7FD00000007FFFFF;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"330331\n");
-    end
-    x = 64'h403F800001000000;
-    y = 64'hB92FFDFFF7FFFFFE;
-    z = 64'hB80FF7FFFF7FFFFE;
-    ans = 64'hB97F7E08390FEFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"330945\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hBFF0000000000001;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"331559\n");
-    end
-    x = 64'h9D3FFFFFFFF7E000;
-    y = 64'h6A9B80B7D3CB8215;
-    z = 64'hBFF0000000000000;
-    ans = 64'hC7EB80B7D3C48666;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"332173\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h434FFFFFEFEFFFFE;
-    ans = 64'h434FFFFFEFEFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"332787\n");
-    end
-    x = 64'hBFCFF7FFF7FFFFFF;
-    y = 64'h3560000007FFFFC0;
-    z = 64'h3F1FFE0000001FFF;
-    ans = 64'h3F1FFE0000001FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"333401\n");
-    end
-    x = 64'hBFF08000003FFFFF;
-    y = 64'hC000000000000001;
-    z = 64'h0010000000000000;
-    ans = 64'h4000800000400000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"334015\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hC1FFFFFFF80007FF;
-    z = 64'hBF50000000003F7E;
-    ans = 64'hBF50000000003F7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"334629\n");
-    end
-    x = 64'h4800000000000E00;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hC00C758EB7D7F0E3;
-    ans = 64'hC820000000000DFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"335243\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hB81FFE0800000000;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"335857\n");
-    end
-    x = 64'h3FFF7FFFFFDFFFFF;
-    y = 64'h37F310487C36B9F7;
-    z = 64'h7FD0000021FFFFFE;
-    ans = 64'h7FD0000021FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"336471\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hC010000000000000;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"337085\n");
-    end
-    x = 64'h37E13C55FB73A123;
-    y = 64'hBBE423B0427AB4FB;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"337699\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hBFFFDFFFFFFFFDFE;
-    ans = 64'hBFFFDFFFFFFFFDFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"338313\n");
-    end
-    x = 64'h000A56DAA543D820;
-    y = 64'hC7E008FFFFFFFFFF;
-    z = 64'hA4F0800007FFFFFF;
-    ans = 64'hA4F0800007FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"338927\n");
-    end
-    x = 64'h3FEFC00000100000;
-    y = 64'hC340000000000000;
-    z = 64'h0000000000000001;
-    ans = 64'hC33FC00000100000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"339541\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hC54FFFFFFF808000;
-    z = 64'h402C0000003FFFFF;
-    ans = 64'h402C0000003FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"340155\n");
-    end
-    x = 64'hBDBFFFFF7FFF7FFF;
-    y = 64'hC340000000000001;
-    z = 64'h469C88C5CBAF8186;
-    ans = 64'h469C88C5CBAF8186;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"340769\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'h401FFFFC00003FFF;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"341383\n");
-    end
-    x = 64'h402FFFFFFDF80000;
-    y = 64'h00207FFFFFFBFFFE;
-    z = 64'hC80FFFFFFFF0000F;
-    ans = 64'hC80FFFFFFFF0000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"341997\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"342611\n");
-    end
-    x = 64'h4008FFCC8CB379C8;
-    y = 64'h4020040000001000;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'h4038860C7FD6BFA6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"343225\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hFFE0000000000001;
-    z = 64'hC03A7FD2CBE40B24;
-    ans = 64'hC03C7FD2CBE40B24;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"343839\n");
-    end
-    x = 64'h47F0040400000000;
-    y = 64'h3FD1FFFFFFFF7FFF;
-    z = 64'hE92013FFFFFFFFFE;
-    ans = 64'hE92013FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"344453\n");
-    end
-    x = 64'h3FD0000080000004;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"345067\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'h3FB3FFFFFFFFFEFE;
-    z = 64'hC090000000002FFF;
-    ans = 64'hC090000000002FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"345681\n");
-    end
-    x = 64'hBFEFFFFFFFFBFFFC;
-    y = 64'hFFF0000000000000;
-    z = 64'hC1D53CF5FDF3680F;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"346295\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hC03000010000007F;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"346909\n");
-    end
-    x = 64'hAB9FFFFFFFFFF1FE;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hC1C8E09D58BA6A9F;
-    ans = 64'hC1C8E09D58BA6A9F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"347523\n");
-    end
-    x = 64'h0010000000000000;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"348137\n");
-    end
-    x = 64'h40EFFFFFFFFDFFEE;
-    y = 64'hBFF0000000000000;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hC0EFFFFFFFFDFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"348751\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h0000000000000000;
-    z = 64'h001FFFFEFFFFFF7F;
-    ans = 64'h001FFFFEFFFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"349365\n");
-    end
-    x = 64'h400040000007FFFE;
-    y = 64'hC020000081FFFFFE;
-    z = 64'hC1F6CE889A397A6A;
-    ans = 64'hC1F6CE889B3D7A72;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"349979\n");
-    end
-    x = 64'h40BFFFC000080000;
-    y = 64'h0000000000000001;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"350593\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h7FDFFFDFEFFFFFFF;
-    z = 64'h0010003FFFFFFFC0;
-    ans = 64'h3FFFFFDFF0000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"351207\n");
-    end
-    x = 64'h7FFFFFFFFFF7FF7F;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'hB81018316CF58422;
-    ans = 64'h7FFFFFFFFFF7FF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"351821\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h21A0FEFFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"352435\n");
-    end
-    x = 64'hDF00000000FEFFFE;
-    y = 64'hC3C00000000FDFFF;
-    z = 64'h3F0FFFFFFFE80000;
-    ans = 64'h62D00000010EDFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"353049\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h0010000000000001;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"353663\n");
-    end
-    x = 64'hBFC38CD9B19C294A;
-    y = 64'hBFCFFFFC3FFFFFFE;
-    z = 64'hBCA0000000000000;
-    ans = 64'h3FA38CD7671AA668;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"354277\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hC0800800FFFFFFFE;
-    ans = 64'hC0800800FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"354891\n");
-    end
-    x = 64'h4338F8B4D98D518E;
-    y = 64'h38101FFFFFFFEFFE;
-    z = 64'hFFD0003FFFFF8000;
-    ans = 64'hFFD0003FFFFF8000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"355505\n");
-    end
-    x = 64'hC2EFFFFFFFFFD7FF;
-    y = 64'h3CA0000000000000;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"356119\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hBFEC8B10292FC3DD;
-    z = 64'hC1CFC000000001FE;
-    ans = 64'hC1CFC000000001FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"356733\n");
-    end
-    x = 64'h77C00000000010FF;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h3FEFFFFDEFFFFFFE;
-    ans = 64'h74800000000010FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"357347\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hC7EFC00000000008;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"357961\n");
-    end
-    x = 64'hB7ED1530D0EED500;
-    y = 64'hC0FFFFFC000000FF;
-    z = 64'hC1C613EAB1D2BC41;
-    ans = 64'hC1C613EAB1D2BC41;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"358575\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h3FD0000000000000;
-    z = 64'hC000000000000000;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'hC000000000000000;
     ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"359189\n");
+    	$fwrite(fp,"300185\n");
     end
-    x = 64'h4020001000000007;
-    y = 64'h39AFFFFFFFF7FFFE;
-    z = 64'h8010000000000001;
-    ans = 64'h39E0000FFFFC0002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h49A0002000000FFF;
+    ReadData2E = 64'h43F0000000BFFFFF;
+    ReadData3E = 64'hFFDF78B1B0067614;
+    ans = 64'hFFDF78B1B0067614;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"359803\n");
+    	$fwrite(fp,"300491\n");
     end
-    x = 64'h0010000000000001;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h43405A4963156D9E;
-    ans = 64'h43405A4963156D9E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC1C00000000001FC;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h81E00000008001FC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"360417\n");
+    	$fwrite(fp,"300797\n");
     end
-    x = 64'h381004000000FFFF;
-    y = 64'hC03FFFFA00000000;
-    z = 64'h42F00000006FFFFF;
-    ans = 64'h42F00000006FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC00080000003FFFE;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'hC7EF484B79B51CC3;
+    ans = 64'hC7EF484B79B51CC3;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"361031\n");
+    	$fwrite(fp,"301103\n");
     end
-    x = 64'hC800000000480000;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hC340000000000001;
-    ans = 64'hC7F000000047FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h409FFEF7FFFFFFFF;
+    ReadData3E = 64'hB7F0000000000F00;
+    ans = 64'hB7F0000000000F00;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"361645\n");
+    	$fwrite(fp,"301409\n");
     end
-    x = 64'h0010000000000001;
-    y = 64'hBFCFFFFFFFFFFBFF;
-    z = 64'h4F5FFFFFDFFFFF7E;
-    ans = 64'h4F5FFFFFDFFFFF7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"362259\n");
-    end
-    x = 64'h41E4A1EAE73D355C;
-    y = 64'h3FE0000000000001;
-    z = 64'h37E2ACB70B24ACB2;
-    ans = 64'h41D4A1EAE73D355D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"362873\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h802FFFFFBC000000;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"363487\n");
-    end
-    x = 64'h403FFFE000FFFFFE;
-    y = 64'hFFFFFFFFFFBFFFF0;
-    z = 64'h402FFEFFFFFFBFFF;
-    ans = 64'hFFFFFFFFFFBFFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"364101\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"364715\n");
-    end
-    x = 64'h800C0454F11FDD89;
-    y = 64'h4018F1AF45350CCF;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h8036BC044C7B4FDB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"365329\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h3FF0000000000001;
-    z = 64'hC09FFFBFFFFFBFFF;
-    ans = 64'hC09FFFBFFFFFBFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"365943\n");
-    end
-    x = 64'hBE4FC000007FFFFE;
-    y = 64'hC3D0080040000000;
-    z = 64'hC03FFFFFFDFFFDFF;
-    ans = 64'h422FCFE07F404000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"366557\n");
-    end
-    x = 64'hBF80000000008000;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC02008000000003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"367171\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hBD0FFFFFD7FFFFFF;
-    z = 64'hC3D00080003FFFFF;
-    ans = 64'hC3D00080003FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"367785\n");
-    end
-    x = 64'h7FDFFEFFFFFF7FFE;
-    y = 64'h4000000000000000;
-    z = 64'h002FFFFFE000007F;
-    ans = 64'h7FEFFEFFFFFF7FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"368399\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h3FCFFFFDFFFBFFFF;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"369013\n");
-    end
-    x = 64'h3FFFFE000007FFFF;
-    y = 64'h41DFFFE000100000;
-    z = 64'hBFE507C600F1F12A;
-    ans = 64'h41EFFDE00202F731;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"369627\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFF;
+    ReadData1E = 64'hB7FFFFFFFFDFF000;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
     ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"370241\n");
+    	$fwrite(fp,"301715\n");
     end
-    x = 64'hBCE00000001FFFFB;
-    y = 64'h400007FF7FFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFE;
+    ReadData1E = 64'hC1E7B18F153C6AE9;
+    ReadData2E = 64'h3FE000000040000F;
+    ReadData3E = 64'hA75000FFFFFE0000;
+    ans = 64'hC1D7B18F159B313C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"302021\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'hBB10000000007FBE;
+    ans = 64'hBB10000000007FBE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"302327\n");
+    end
+    ReadData1E = 64'h7FD00000000E0000;
+    ReadData2E = 64'hB33E000001FFFFFF;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'hF31E0000021A3FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"302633\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h3FF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"302939\n");
+    end
+    ReadData1E = 64'h3FCFFC0000000003;
+    ReadData2E = 64'hD080E00000000000;
+    ReadData3E = 64'h41ED6C31252172C3;
+    ans = 64'hD060DDE400000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"303245\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBFF613FC6392E9AA;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'h801613FC6392E9A9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"303551\n");
+    end
+    ReadData1E = 64'h40407FFFFFFFBFFF;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'hC7F0000FFC000000;
+    ans = 64'hC7F0000FFC000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"303857\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h416FFFFFFFFFDFF6;
+    ReadData3E = 64'h40DE7B3AA73E78BE;
+    ans = 64'h40DE7B3AA73E78BE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"304163\n");
+    end
+    ReadData1E = 64'h380FFFFEFFC00000;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h3FDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"304469\n");
+    end
+    ReadData1E = 64'h6690003F7FFFFFFF;
+    ReadData2E = 64'hFFEFFDFFDFFFFFFF;
+    ReadData3E = 64'hBA300000407FFFFE;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"304775\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'hC1E0020000000200;
+    ans = 64'hC1E0020000000200;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"305081\n");
+    end
+    ReadData1E = 64'h890BFFFFFFF80000;
+    ReadData2E = 64'h7FD0001000000002;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'hC8EC001BFFF7FFFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"305387\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hBFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"305693\n");
+    end
+    ReadData1E = 64'h4080000007FFFEFE;
+    ReadData2E = 64'hC80FE00000000004;
+    ReadData3E = 64'h001FFBBFFFFFFFFF;
+    ans = 64'hC89FE0000FEFFE02;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"305999\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hB53FFFFFFFF7BFFE;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"306305\n");
+    end
+    ReadData1E = 64'hC1BBFFFFFFFFF800;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'hC01200007FFFFFFE;
+    ans = 64'hC50BFFFFFFFFF802;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"306611\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC0E8639CEABADD60;
+    ReadData3E = 64'h407FFFFFF000000E;
+    ans = 64'h407FFFFFF000000E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"306917\n");
+    end
+    ReadData1E = 64'h403E9B00B0A9304B;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'h439E9B00B0A9304A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"307223\n");
+    end
+    ReadData1E = 64'h480FFFFDFFF80000;
+    ReadData2E = 64'h3F41BFFFFFFFFFFF;
+    ReadData3E = 64'hC1C000000000FFEF;
+    ans = 64'h4761BFFEE3FB8FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"307529\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'h3CE80001FFFFFFFE;
+    ans = 64'h3CE80001FFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"307835\n");
+    end
+    ReadData1E = 64'h7FD0002FFFFFFFFF;
+    ReadData2E = 64'hB8700000800FFFFF;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hF85000308011802E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"308141\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h4004000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"308447\n");
+    end
+    ReadData1E = 64'h3FEFFFFFFFFFF807;
+    ReadData2E = 64'h403000FFFFFFFFFD;
+    ReadData3E = 64'h8000000000FFFFFB;
+    ans = 64'h403000FFFFFFFC00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"308753\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC00BC838B3BBB5A9;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"309059\n");
+    end
+    ReadData1E = 64'hBFA007FFFFFFFBFF;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'h3FB00000000201FF;
+    ans = 64'hFF9007FFFFFFFC00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"309365\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h48B5B44331874F02;
+    ReadData3E = 64'h41CFFE00FFFFFFFF;
+    ans = 64'h41CFFE00FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"309671\n");
+    end
+    ReadData1E = 64'h000FFFFFFFFFDFBE;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'h400FFFFFFFFFBF7B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"309977\n");
+    end
+    ReadData1E = 64'h41CF7FFFFFFFFFF0;
+    ReadData2E = 64'h7FEFFDFFFEFFFFFE;
+    ReadData3E = 64'h3FE96EA68E3FBB6C;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"310283\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hBF801FFFFFFFFEFF;
+    ans = 64'h400FEFE000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"310589\n");
+    end
+    ReadData1E = 64'h00201000007FFFFE;
+    ReadData2E = 64'h480CFFB7FE0DACA9;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"310895\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'h400DFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"311201\n");
+    end
+    ReadData1E = 64'hCE44B2478F9C2274;
+    ReadData2E = 64'h434003FDFFFFFFFF;
+    ReadData3E = 64'hD79800000001FFFE;
+    ans = 64'hD79800000001FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"311507\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC004F9F07751D02C;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"311813\n");
+    end
+    ReadData1E = 64'h2DB0041FFFFFFFFF;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h3FE960A47AF95278;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"312119\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h7FE00003FFFFFFF6;
+    ReadData3E = 64'h7FE0013FFFFFFFFE;
+    ans = 64'h7FE0013FFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"312425\n");
+    end
+    ReadData1E = 64'hBFFFFE0000003FFE;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"312731\n");
+    end
+    ReadData1E = 64'hC02FFFFFFFBFFFFF;
+    ReadData2E = 64'hB39FFFFFFFFFF808;
+    ReadData3E = 64'h43FFFFF000002000;
+    ans = 64'h43FFFFF000002000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"313037\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hC03FBF7FFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"313343\n");
+    end
+    ReadData1E = 64'h381FFFEEFFFFFFFF;
+    ReadData2E = 64'hB7EFF80000008000;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"313649\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h3CA0000000000001;
     ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"370855\n");
+    	$fwrite(fp,"313955\n");
     end
-    x = 64'h0010000000000001;
-    y = 64'h4010000000000000;
-    z = 64'h40A0008000000200;
-    ans = 64'h40A0008000000200;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD000003FFFFE00;
+    ReadData2E = 64'h4BC000007FFFC000;
+    ReadData3E = 64'hBFDFAA56060806BE;
+    ans = 64'h4BA00000BFFFC000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"371469\n");
+    	$fwrite(fp,"314261\n");
     end
-    x = 64'h3FDFF5989FAB38C7;
-    y = 64'hB810000400000002;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hFFEFFFFFFFEFFFFC;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC340000000000003;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"372083\n");
+    	$fwrite(fp,"314567\n");
     end
-    x = 64'hDE7FFFEFFFFFFFBF;
-    y = 64'h4010000000000001;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hDE9FFFEFFFFFFFC1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC0307FEFFFFFFFFF;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'hBDD00000080FFFFF;
+    ans = 64'hBDD00000080FFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"372697\n");
+    	$fwrite(fp,"314873\n");
     end
-    x = 64'h0010000000000001;
-    y = 64'h80001FFFF7FFFFFE;
-    z = 64'hC001FFFFFFFFFFDF;
-    ans = 64'hC001FFFFFFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC3FFFC0000FFFFFE;
+    ReadData3E = 64'hBFCFFFFEFFEFFFFE;
+    ans = 64'hBFCFFFFEFFEFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"373311\n");
+    	$fwrite(fp,"315179\n");
     end
-    x = 64'hC010003FFFFFFFFF;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hC1FB6BC37B0AF313;
-    ans = 64'hC1FB6BC37D0AFB13;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h40C34F729EDBEC45;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'h000FFFFFFFFFD95F;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"373925\n");
+    	$fwrite(fp,"315485\n");
     end
-    x = 64'h0010000000000001;
-    y = 64'hB8BFFFF80000FFFE;
-    z = 64'h3CAFFFFFFFFFFFFE;
+    ReadData1E = 64'hC03FFFEFFFFFFFDE;
+    ReadData2E = 64'h8010800000004000;
+    ReadData3E = 64'h41CC0000000003FF;
+    ans = 64'h41CC0000000003FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"315791\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'h43FFFFFFEEFFFFFF;
+    ans = 64'h43FFFFFFEEFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"316097\n");
+    end
+    ReadData1E = 64'h41C00020000000FF;
+    ReadData2E = 64'hC07A332FE70D0382;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'hC24A33644D6C933E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"316403\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h801FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"316709\n");
+    end
+    ReadData1E = 64'h3D6FFFFE000FFFFE;
+    ReadData2E = 64'hC03000407FFFFFFF;
+    ReadData3E = 64'h402FFFFFF80001FE;
+    ans = 64'h402FFFFFF7FFE1FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"317015\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h41D524236A0D87CB;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h401FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"317321\n");
+    end
+    ReadData1E = 64'h41C807C515B87415;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'hCD0080000001FFFF;
+    ans = 64'hCD0080000001FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"317627\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h3F4400000000001E;
+    ReadData3E = 64'hC1DFFFFFFFFBFFFA;
+    ans = 64'hC1DFFFFFFFFBFFFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"317933\n");
+    end
+    ReadData1E = 64'h41CFF80000000007;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h81EFF80000000007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"318239\n");
+    end
+    ReadData1E = 64'hC03003FFF7FFFFFE;
+    ReadData2E = 64'hC80F8FFFFFFFFFFF;
+    ReadData3E = 64'h3FBDFFFFFF800000;
+    ans = 64'h484F97E3F037FFFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"318545\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'h38E0000FFFFFFF80;
+    ans = 64'h38E0000FFFFFFF80;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"318851\n");
+    end
+    ReadData1E = 64'hBFCFFFFFFC000008;
+    ReadData2E = 64'h1ACFFFFFFF800010;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"319157\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'h000FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"319463\n");
+    end
+    ReadData1E = 64'hBFC195D722242CFC;
+    ReadData2E = 64'h43FA8BAAFEAC312F;
+    ReadData3E = 64'h7FF44DE4CC2EAF61;
+    ans = 64'h7FFC4DE4CC2EAF61;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"319769\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hFFF000000003FFFB;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hFFF800000003FFFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"320075\n");
+    end
+    ReadData1E = 64'h43F00000007FFFFE;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFBFFFF7FFEFFFFF;
+    ans = 64'hBFBFFFF7FFEFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"320381\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h41EBFFFFFC000000;
+    ReadData3E = 64'h41403FEFFFFFFFFE;
+    ans = 64'h41403FEFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"320687\n");
+    end
+    ReadData1E = 64'h381FF7FFFFFFFFDF;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"320993\n");
+    end
+    ReadData1E = 64'h300EFFFFFFFFFFDE;
+    ReadData2E = 64'h41FFF7FFDFFFFFFF;
+    ReadData3E = 64'h404FFFFFFF9FFFFF;
+    ans = 64'h404FFFFFFF9FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"321299\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'h43B00000007FFFF8;
+    ans = 64'h43B00000007FFFF8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"321605\n");
+    end
+    ReadData1E = 64'h31C003FFFFFBFFFE;
+    ReadData2E = 64'h3FB929CE7C20406E;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
     ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"374539\n");
+    	$fwrite(fp,"321911\n");
     end
-    x = 64'h38A8B771F85C15DA;
-    y = 64'hBFDFFFFEFFFFFFBE;
-    z = 64'h3E6FFFFFFC03FFFE;
-    ans = 64'h3E6FFFFFFC03FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h8000000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"375153\n");
+    	$fwrite(fp,"322217\n");
     end
-    x = 64'h0010000000000001;
-    y = 64'h4340000000000001;
-    z = 64'hBFDFFFFFFFFFFFFE;
+    ReadData1E = 64'hB7F0000000000FFC;
+    ReadData2E = 64'hC3EEE26ECB4D48FA;
+    ReadData3E = 64'h41E01FFFFF7FFFFE;
+    ans = 64'h41E01FFFFF7FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"322523\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h5E3FB1EF5708D61C;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'h4000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"322829\n");
+    end
+    ReadData1E = 64'hC09000003FFFBFFF;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'hC02FFFFFFFFE01FF;
+    ans = 64'hC02FFFFFFFFE017F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"323135\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h20BDA441CA99D67B;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFD;
+    ans = 64'h3FFFFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"323441\n");
+    end
+    ReadData1E = 64'h41C00001FE000000;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"323747\n");
+    end
+    ReadData1E = 64'hC02FFF0000000003;
+    ReadData2E = 64'hD7F000000000007A;
+    ReadData3E = 64'h316B40A4972E3E8C;
+    ans = 64'h582FFF00000000F7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"324053\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'hC00FFFFC00001FFF;
+    ans = 64'hC00FFFFC00001FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"324359\n");
+    end
+    ReadData1E = 64'h401007FFDFFFFFFE;
+    ReadData2E = 64'h41EFFFFFFFFFFF7E;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'h421007FFDFFFFFBD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"324665\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"324971\n");
+    end
+    ReadData1E = 64'hB81F775CD1DFBCE5;
+    ReadData2E = 64'hC5AFFFFFFFEFFFFE;
+    ReadData3E = 64'h41DFFFFFF00FFFFE;
+    ans = 64'h41DFFFFFF00FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"325277\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBFE72B4771A92771;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hBFF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"325583\n");
+    end
+    ReadData1E = 64'h43EFFFFFC00007FE;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'hC34F000003FFFFFF;
+    ans = 64'hC3E007BFE00103FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"325889\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC0DFF000003FFFFF;
+    ReadData3E = 64'hA751FFFFFFFFFF7E;
+    ans = 64'hA751FFFFFFFFFF7E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"326195\n");
+    end
+    ReadData1E = 64'h3F243DDDF2B81DCE;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"326501\n");
+    end
+    ReadData1E = 64'hBD86FC7AA6E86ECB;
+    ReadData2E = 64'hC3007FFFFFFFFFFF;
+    ReadData3E = 64'hBFF00101FFFFFFFF;
+    ans = 64'h4097B05E3B9FB240;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"326807\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'h401FFFF800FFFFFF;
+    ans = 64'h401FFFF800FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"327113\n");
+    end
+    ReadData1E = 64'h40F0020000000007;
+    ReadData2E = 64'hBA10000003FFF000;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'hBB10020004007005;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"327419\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"327725\n");
+    end
+    ReadData1E = 64'hFFD0023FFFFFFFFF;
+    ReadData2E = 64'hB80FFFFE000000FE;
+    ReadData3E = 64'hBFF0000002080000;
+    ans = 64'h77F0023EFFDC007E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"328031\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h402FF0000001FFFF;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h3FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"328337\n");
+    end
+    ReadData1E = 64'h001EFFFFFFFFFFFA;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'h41EFFFFFFFFF7FFA;
+    ans = 64'h41EFFFFFFFFF7FFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"328643\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h400FFFBFFFFFFFFE;
+    ReadData3E = 64'hBFEF000000000006;
+    ans = 64'hBFEF000000000006;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"328949\n");
+    end
+    ReadData1E = 64'h2CA00001DFFFFFFE;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h4340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"329255\n");
+    end
+    ReadData1E = 64'h3FBFFFFC03FFFFFE;
+    ReadData2E = 64'h41D2003FFFFFFFFF;
+    ReadData3E = 64'hB81FFF7FBFFFFFFF;
+    ans = 64'h41A2003DC23807FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"329561\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFC8D4B898AE6753;
+    ans = 64'hBFC8D4B898AE6753;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"329867\n");
+    end
+    ReadData1E = 64'h37F0811ECCA520CC;
+    ReadData2E = 64'hB5EC0F0DCEE7205D;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'hADECF17D3156B094;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"330173\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"330479\n");
+    end
+    ReadData1E = 64'h47E800000003FFFF;
+    ReadData2E = 64'h002D21C92796619C;
+    ReadData3E = 64'h8020000000000000;
+    ans = 64'h0825D956DDB46D6D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"330785\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h380FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
     ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"331091\n");
+    end
+    ReadData1E = 64'h0010000000010002;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'hBFC00000003FEFFF;
+    ans = 64'hBFC00000003FEFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"331397\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC7F3FFFFFF000000;
+    ReadData3E = 64'hC1AFFFFFFF7DFFFF;
+    ans = 64'hC1AFFFFFFF7DFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"331703\n");
+    end
+    ReadData1E = 64'hC8BFFFFFFFFBFDFE;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'h48BFFFFFFFFBFE00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"332009\n");
+    end
+    ReadData1E = 64'hBE6F80000000007F;
+    ReadData2E = 64'h3E8B72F2BC14CB1E;
+    ReadData3E = 64'hC230976CFE95CEB9;
+    ans = 64'hC230976CFE95CEB9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"332315\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hC44FFFFF7FFFFF80;
+    ans = 64'hC44FFFFF7FFFFF80;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"332621\n");
+    end
+    ReadData1E = 64'hC1F01FFFFFFF0000;
+    ReadData2E = 64'hF298EF2E7DB85567;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"332927\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h4340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"333233\n");
+    end
+    ReadData1E = 64'hBF5FD227B86CA879;
+    ReadData2E = 64'h40200000003FFFFC;
+    ReadData3E = 64'hD9BFFFFC1FFFFFFF;
+    ans = 64'hD9BFFFFC1FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"333539\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h403D53A968AE85F4;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"333845\n");
+    end
+    ReadData1E = 64'h401FFFFDC0000000;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'hCF8F800007FFFFFF;
+    ans = 64'hCF8F800007FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"334151\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC1D0803FFFFFFFFF;
+    ReadData3E = 64'h41D9081CD2377743;
+    ans = 64'h41D9081CD2377743;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"334457\n");
+    end
+    ReadData1E = 64'h78001E0C150FC0CA;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'hF8101E0C150FC0CB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"334763\n");
+    end
+    ReadData1E = 64'hC1E0000FFFFFFEFF;
+    ReadData2E = 64'hBFF20000000003FF;
+    ReadData3E = 64'h3CA2B9DBAAB26581;
+    ans = 64'h41E20012000002DE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"335069\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h65E05E479AF5AEB5;
+    ans = 64'h65E05E479AF5AEB5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"335375\n");
+    end
+    ReadData1E = 64'hC1F00000000400FF;
+    ReadData2E = 64'h400F51AB9CFD5497;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"335681\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"335987\n");
+    end
+    ReadData1E = 64'h3ECFFC0000000010;
+    ReadData2E = 64'hC0FFFFF8000FFFFF;
+    ReadData3E = 64'hBFCFFF7FFFFBFFFF;
+    ans = 64'hBFE7FDDC0086FF07;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"336293\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC0000001000001FE;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCA0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"336599\n");
+    end
+    ReadData1E = 64'h37EFFFFC00000004;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'hC1CFFFFFBF800000;
+    ans = 64'hC1CFFFFFBF800000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"336905\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC5C679594BB014C1;
+    ReadData3E = 64'h3380000203FFFFFF;
+    ans = 64'h3380000203FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"337211\n");
+    end
+    ReadData1E = 64'h403585434B1B77D6;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hC05605434B1B77D6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"337517\n");
+    end
+    ReadData1E = 64'hBE3FFFFFFFFFE07F;
+    ReadData2E = 64'h3F9FFFFFFFF87FFF;
+    ReadData3E = 64'h3EA000000003FFBF;
+    ans = 64'h3E9FFC0000080072;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"337823\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'hC07238B056832559;
+    ans = 64'hC07238B056832559;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"338129\n");
+    end
+    ReadData1E = 64'hC7FF635B2DA8AC6C;
+    ReadData2E = 64'hBF300001FFFE0000;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"338435\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h400FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"338741\n");
+    end
+    ReadData1E = 64'h8004E9A86C24788F;
+    ReadData2E = 64'h40100000FFFFFC00;
+    ReadData3E = 64'h41BFDF7FFFFFFFFF;
+    ans = 64'h41BFDF7FFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"339047\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBF3FFF00000FFFFE;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h001FFE000FFFFEFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"339353\n");
+    end
+    ReadData1E = 64'hB63FFFFFFFFFFDFF;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'hA5BE0000000003FF;
+    ans = 64'h366FFFFFFFFFFDFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"339659\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hB9F000000007FFFA;
+    ReadData3E = 64'hC8061A6CA9E4273A;
+    ans = 64'hC8061A6CA9E4273A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"339965\n");
+    end
+    ReadData1E = 64'h7FF0010000000200;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h7FF8010000000200;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"340271\n");
+    end
+    ReadData1E = 64'hC140400000000007;
+    ReadData2E = 64'hC747571F3869690F;
+    ReadData3E = 64'h43400003FFF7FFFF;
+    ans = 64'h4897B47BB54B0EBD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"340577\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'hC2BFBFFEFFFFFFFF;
+    ans = 64'hC2BFBFFEFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"340883\n");
+    end
+    ReadData1E = 64'hBFFFFFFFC00003FF;
+    ReadData2E = 64'hC01274DD0FBADA9C;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h4350000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"341189\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hBFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"341495\n");
+    end
+    ReadData1E = 64'h380F001FFFFFFFFF;
+    ReadData2E = 64'hAC0FDFFFFC000000;
+    ReadData3E = 64'hBFC0000000004007;
+    ans = 64'hBFC0000000004007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"341801\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC0A000103FFFFFFE;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h80C002103FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"342107\n");
+    end
+    ReadData1E = 64'hB59FC00000000003;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'hB80FFFFFFFFFFFDA;
+    ans = 64'h38FFBFC000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"342413\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBCC3CFBD727D2506;
+    ReadData3E = 64'hC1C0100000001FFF;
+    ans = 64'hC1C0100000001FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"342719\n");
+    end
+    ReadData1E = 64'hFFEE000080000000;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"343025\n");
+    end
+    ReadData1E = 64'h39EFFFF000000040;
+    ReadData2E = 64'hBFA0000000020FFF;
+    ReadData3E = 64'hBD117042903CB8AA;
+    ans = 64'hBD117042903CB8AA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"343331\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'h42800000017FFFFF;
+    ans = 64'h42800000017FEFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"343637\n");
+    end
+    ReadData1E = 64'hB9BFFFFFE0004000;
+    ReadData2E = 64'hBF90200000000007;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hC01FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"343943\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'hBFF0000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"344249\n");
+    end
+    ReadData1E = 64'h3FF00080003FFFFF;
+    ReadData2E = 64'h43EFFFFF7FFFFDFF;
+    ReadData3E = 64'hBFFFFFFF7F7FFFFF;
+    ans = 64'h43F0007FC03DFEFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"344555\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC1CFFFFFFFC0FFFE;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'h81EFFFFFFFC0FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"344861\n");
+    end
+    ReadData1E = 64'hB02FFBFFFEFFFFFF;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h2F20000000100000;
+    ans = 64'h702FFBFFFEFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"345167\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hC1FFFFFFF8000010;
+    ReadData3E = 64'h0010000840000000;
+    ans = 64'h821FFFFFF7F00008;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"345473\n");
+    end
+    ReadData1E = 64'h381007C000000000;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'hF81007BFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"345779\n");
+    end
+    ReadData1E = 64'hBF562488B8D64371;
+    ReadData2E = 64'h92A0000017FFFFFF;
+    ReadData3E = 64'h39EFDFFFFFFFDFFE;
+    ans = 64'h39EFDFFFFFFFDFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"346085\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h403E715430E93B27;
+    ans = 64'h403A715430E93B27;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"346391\n");
+    end
+    ReadData1E = 64'h3A90000000BFFFFF;
+    ReadData2E = 64'hC1D671BF3B5F1C48;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"346697\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"347003\n");
+    end
+    ReadData1E = 64'hB7DFFFFFFFFFFE00;
+    ReadData2E = 64'h3F907FFFFFFFF7FE;
+    ReadData3E = 64'hBF93C0A23CC11A26;
+    ans = 64'hBF93C0A23CC11A26;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"347309\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'h7FF00017FFFFFFFF;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF80017FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"347615\n");
+    end
+    ReadData1E = 64'h3FC0000000050000;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'h4025438262DA06B0;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"347921\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hBD9100000000003F;
+    ReadData3E = 64'hC01FFFFE003FFFFF;
+    ans = 64'hC01FFFFE003FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"348227\n");
+    end
+    ReadData1E = 64'hBFD00001FFFFFE00;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"348533\n");
+    end
+    ReadData1E = 64'h000FFFFFFFDFFEFF;
+    ReadData2E = 64'hBCA00003FFFFFFF0;
+    ReadData3E = 64'h41E207FFFFFFFFFF;
+    ans = 64'h41E207FFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"348839\n");
+    end
+    ReadData1E = 64'h0010000000000000;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FC4726CAF9F0AC5;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"349145\n");
+    end
+    ReadData1E = 64'hC1EC4292DAD85B10;
+    ReadData2E = 64'h0FD00007FFFEFFFE;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"349451\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h3FDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"349757\n");
+    end
+    ReadData1E = 64'hC510000000200007;
+    ReadData2E = 64'h37E8254245857C30;
+    ReadData3E = 64'h215001FFFFFFF7FE;
+    ans = 64'hBD08254245B5C6BF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"350063\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"350369\n");
+    end
+    ReadData1E = 64'hBFC000000FFFFFC0;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'h40CC6452234E22D5;
+    ans = 64'h40CC6452234E22D5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"350675\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h313FFFFF8000000E;
+    ReadData3E = 64'h4090400000008000;
+    ans = 64'h4090400000008000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"350981\n");
+    end
+    ReadData1E = 64'h43F5973D6929059F;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h3CA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"351287\n");
+    end
+    ReadData1E = 64'hFA5618AB76807DB4;
+    ReadData2E = 64'hA9B684B73C005DA3;
+    ReadData3E = 64'h40CFFBFFFDFFFFFF;
+    ans = 64'h641F19345688708F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"351593\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFD40007FFFFFFFF;
+    ans = 64'hBFD40007FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"351899\n");
+    end
+    ReadData1E = 64'hBE50000000000401;
+    ReadData2E = 64'hC00FFFF03FFFFFFF;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h4000000007FFFC10;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"352205\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hBCAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"352511\n");
+    end
+    ReadData1E = 64'hE0B100000000003F;
+    ReadData2E = 64'hC10F800000003FFE;
+    ReadData3E = 64'hBFDFFFFFFFFFDFFD;
+    ans = 64'h61D0BC000000223D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"352817\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3FEFFFFFFFFFC002;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h434FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"353123\n");
+    end
+    ReadData1E = 64'h417FFF7FFFFFFF00;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'h37FA53BB21817EC2;
+    ans = 64'h37FA53BB21817EC2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"353429\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3DC39B8B3CE1D868;
+    ReadData3E = 64'hC96FFFFFFBFFE000;
+    ans = 64'hC96FFFFFFBFFE000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"353735\n");
+    end
+    ReadData1E = 64'h3FF00000007FFFF7;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h00000000007FFFF7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"354041\n");
+    end
+    ReadData1E = 64'h400FFFFFFFEFF000;
+    ReadData2E = 64'hB7FFFFFFFFFFF040;
+    ReadData3E = 64'hC1EFFFFFFF01FFFF;
+    ans = 64'hC1EFFFFFFF01FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"354347\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'h312EFFFFFFFFFFFF;
+    ans = 64'h312EFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"354653\n");
+    end
+    ReadData1E = 64'hC3F003FFFF7FFFFF;
+    ReadData2E = 64'hC1FBFFFFFFFEFFFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'h45FC06FFFF1EFFBD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"354959\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h3CA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"355265\n");
+    end
+    ReadData1E = 64'h4EA00000000007FE;
+    ReadData2E = 64'h43EE5D7578A9E4C9;
+    ReadData3E = 64'hC0108000000003FF;
+    ans = 64'h529E5D7578A9F3F4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"355571\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC00000DFFFFFFFFF;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'hC340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"355877\n");
+    end
+    ReadData1E = 64'h400FFEDFFFFFFFFF;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'hC00FFFFFFBFFFBFE;
+    ans = 64'hC00FFFFFFBFFFBFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"356183\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hCF22DB34B40B610A;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"356489\n");
+    end
+    ReadData1E = 64'h794CFFFFFFFFFFFE;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h75FD000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"356795\n");
+    end
+    ReadData1E = 64'hBFDFFFFFF0001000;
+    ReadData2E = 64'h43CFFFC0003FFFFF;
+    ReadData3E = 64'hC7F31244A4CB68E0;
+    ans = 64'hC7F31244A4CB68E0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"357101\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'hC7E000200000003F;
+    ans = 64'hC7E000200000003F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"357407\n");
+    end
+    ReadData1E = 64'hFBA7EF96594DB2B4;
+    ReadData2E = 64'hC37FFFFFFFFFEBFE;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h7F37EF96594DA3BD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"357713\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h8010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"358019\n");
+    end
+    ReadData1E = 64'h4630000000FFFFFF;
+    ReadData2E = 64'h41E07FFFFFFFBFFF;
+    ReadData3E = 64'h3FBFFFAFFFFFFFFF;
+    ans = 64'h482080000107BFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"358325\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3ABFFFFC40000000;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h4010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"358631\n");
+    end
+    ReadData1E = 64'h436F7FFDFFFFFFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'hC01020007FFFFFFF;
+    ans = 64'h40276FFDBFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"358937\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC1E0008000002000;
+    ReadData3E = 64'h7FD0000002200000;
+    ans = 64'h7FD0000002200000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"359243\n");
+    end
+    ReadData1E = 64'hB7EFFFFFFFFFD000;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"359549\n");
+    end
+    ReadData1E = 64'h3FF008003FFFFFFF;
+    ReadData2E = 64'hC00FFFF0007FFFFF;
+    ReadData3E = 64'h80DFFC0000000003;
+    ans = 64'hC01007F83C3FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"359855\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'hBFB46BA6BE17B26F;
+    ans = 64'hBFB46BA6BE17B26F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"360161\n");
+    end
+    ReadData1E = 64'h42A2C1EA3B54D9AE;
+    ReadData2E = 64'h7FE00000007FFFE0;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"360467\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h0017FFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"360773\n");
+    end
+    ReadData1E = 64'h40086C9CAE34D324;
+    ReadData2E = 64'hC00FFFBFFBFFFFFF;
+    ReadData3E = 64'hC020000001FFDFFF;
+    ans = 64'hC0343635E9F6E191;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"361079\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3E36E176EB8922BE;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hC00FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"361385\n");
+    end
+    ReadData1E = 64'hC0600007FFFFBFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FB47FFFFFFFFFFE;
+    ans = 64'hC04FF5CFFFFF7FFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"361691\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC7CFFFFFF0000003;
+    ReadData3E = 64'hB7EFFFFFFFFF8800;
+    ans = 64'hB7EFFFFFFFFF8800;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"361997\n");
+    end
+    ReadData1E = 64'hBCA0807FFFFFFFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"362303\n");
+    end
+    ReadData1E = 64'h4032001FFFFFFFFF;
+    ReadData2E = 64'hE0300040003FFFFE;
+    ReadData3E = 64'hC8664720EB83783B;
+    ans = 64'hE072006800C8007D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"362609\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'h3FF020003FFFFFFF;
+    ans = 64'h3FF020003FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"362915\n");
+    end
+    ReadData1E = 64'h40700000000FFFFE;
+    ReadData2E = 64'h48028D94CD5609B6;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'h48828D94CD689748;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"363221\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"363527\n");
+    end
+    ReadData1E = 64'h41E932AE9C561D16;
+    ReadData2E = 64'hBFBE902517750DF2;
+    ReadData3E = 64'hC1FFFFFFFFFFFE02;
+    ans = 64'hC200C08827CB14EC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"363833\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3FFFF80080000000;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"364139\n");
+    end
+    ReadData1E = 64'h4180200000200000;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h37E6BEA376F569FE;
+    ans = 64'h41802000001FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"364445\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h0012DB0FA04B1CAC;
+    ReadData3E = 64'h3D70000020004000;
+    ans = 64'h3D70000020004000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"364751\n");
+    end
+    ReadData1E = 64'h41EFFFFFF800FFFE;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"365057\n");
+    end
+    ReadData1E = 64'hC7EFF00FFFFFFFFE;
+    ReadData2E = 64'hC1FFFFFFDFFFFBFF;
+    ReadData3E = 64'hBB9000400000007F;
+    ans = 64'h49FFF00FE00FEBFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"365363\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'h33501FFF7FFFFFFF;
+    ans = 64'h33501FFF7FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"365669\n");
+    end
+    ReadData1E = 64'hC1EFFE000000001E;
+    ReadData2E = 64'h402FFFFFFFFEF7FE;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'hC22FFDFFFFFEF82D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"365975\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"366281\n");
+    end
+    ReadData1E = 64'hB930FFFFFFFFFBFF;
+    ReadData2E = 64'h4031FFFFFFFFFF80;
+    ReadData3E = 64'hBEBE982A1C07F2DE;
+    ans = 64'hBEBE982A1C07F2DE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"366587\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hB800000000002FFF;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"366893\n");
+    end
+    ReadData1E = 64'hC015FCF3430061EA;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hC7F98E9DA34917BB;
+    ans = 64'hC7F98E9DA34917BB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"367199\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h4057FFC000000000;
+    ReadData3E = 64'h3B2000000000FFF7;
+    ans = 64'h3B2000000000FFF7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"367505\n");
+    end
+    ReadData1E = 64'hFFEFF00000000200;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"367811\n");
+    end
+    ReadData1E = 64'hBFBAE3CE9204B8B5;
+    ReadData2E = 64'h400FFFFE00000002;
+    ReadData3E = 64'h403FFFFFFFFFC800;
+    ans = 64'h403F9470CC70A8C2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"368117\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC1FFFFFCFFFFFFFE;
+    ans = 64'hC1FFFFFCFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"368423\n");
+    end
+    ReadData1E = 64'h3C5FFDFFFFDFFFFE;
+    ReadData2E = 64'h0004DB2EE93B91E9;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'h0010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"368729\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"369035\n");
+    end
+    ReadData1E = 64'hC1D0000000003FBF;
+    ReadData2E = 64'hBFE0000FFEFFFFFF;
+    ReadData3E = 64'h46927FFFFFFFFFFF;
+    ans = 64'h46927FFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"369341\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h41F0001FFFFFFFF0;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h3FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"369647\n");
+    end
+    ReadData1E = 64'h380FFFFFE0000100;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'hBFA0000200200000;
+    ans = 64'hBFA0000200200000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"369953\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC1D0008000001000;
+    ReadData3E = 64'hC050000000040006;
+    ans = 64'hC050000000040006;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"370259\n");
+    end
+    ReadData1E = 64'hC3E0000000BFFFFE;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'hC400000000BFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"370565\n");
+    end
+    ReadData1E = 64'hC3DFC84C1C3C21EC;
+    ReadData2E = 64'hB41FFFF001FFFFFF;
+    ReadData3E = 64'hC4DFFFFFFFFFFE20;
+    ans = 64'hC4DFFFFFFFFFFE20;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"370871\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'h24F0000000003FFD;
+    ans = 64'h24F0000000003FFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"371177\n");
+    end
+    ReadData1E = 64'hBFD000FFFFEFFFFF;
+    ReadData2E = 64'hBFBFFFFFC0000400;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h3FA000FFDFEE01FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"371483\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"371789\n");
+    end
+    ReadData1E = 64'h3FC0008FFFFFFFFF;
+    ReadData2E = 64'hC3D000000FFFFFFC;
+    ReadData3E = 64'hC02FFEFFF8000000;
+    ans = 64'hC3A0009010008FFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"372095\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h1BDC6B59EFED4540;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"372401\n");
+    end
+    ReadData1E = 64'h4007F0F830234BBC;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'hC071FEFFFFFFFFFF;
+    ans = 64'hC0713F783E7EE5A1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"372707\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hCE60000800000003;
+    ReadData3E = 64'h3FD0000200000001;
+    ans = 64'h3FD0000200000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"373013\n");
+    end
+    ReadData1E = 64'h45BFFFFBF8000000;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'h45DFFFFBF8000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"373319\n");
+    end
+    ReadData1E = 64'h52CFFFEFFFFFFBFE;
+    ReadData2E = 64'hC3DCF5E2283E4645;
+    ReadData3E = 64'h3FDFFFC004000000;
+    ans = 64'hD6BCF5D3AD4D2E85;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"373625\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'h417FFDFFFFFFFFE0;
+    ans = 64'h417FFDFFFFFFFFE0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"373931\n");
+    end
+    ReadData1E = 64'h3FC1E79A840CE4A2;
+    ReadData2E = 64'hC0202000000007FE;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"374237\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h401FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"374543\n");
+    end
+    ReadData1E = 64'h43EFFFF9FFFFFFFF;
+    ReadData2E = 64'hBB91FFFFFFF7FFFE;
+    ReadData3E = 64'hBFF00000400000FF;
+    ans = 64'hBFF04800327FE0FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"374849\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hB8BFFFF80000FFFE;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h3CAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"375155\n");
+    end
+    ReadData1E = 64'hB7F781B7D9BC6FE7;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'h29EA81D8C86B6006;
+    ans = 64'hBB4781B7D9BC6FE7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"375461\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBF252B3EDD51DAD4;
+    ReadData3E = 64'h3F4001FFFF7FFFFF;
+    ans = 64'h3F4001FFFF7FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
@@ -28803,7189 +47920,11971 @@ initial
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
     	$fwrite(fp,"375767\n");
     end
-    x = 64'h4FCAAD2F5FC33B20;
-    y = 64'h376FF7EFFFFFFFFE;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hA980002200000000;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'h4000000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"376381\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hC007F2D5B3D5ED32;
-    ans = 64'hC007F2D5B3D5ED32;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"376995\n");
-    end
-    x = 64'h402FFFFBFFFFFBFF;
-    y = 64'hC7E659F40C826256;
-    z = 64'hBFEC06F9894A7A32;
-    ans = 64'hC82659F14143DDFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"377609\n");
-    end
-    x = 64'hBCAF5F38CB074578;
-    y = 64'h7FE0000000000000;
-    z = 64'hC000000000000000;
-    ans = 64'hFC9F5F38CB074578;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"378223\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hC01FEFFFFFFF8000;
-    z = 64'h3FB7FFFFFFFFFFDF;
-    ans = 64'h3FB7FFFFFFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"378837\n");
-    end
-    x = 64'h3DCD677997FE3E3B;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hFAC3698D88B4775C;
-    ans = 64'h7DCD677997FE3E27;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"379451\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h56600000FFFDFFFE;
-    z = 64'h3CA0000000000000;
-    ans = 64'h3CA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"380065\n");
-    end
-    x = 64'hC5D0080000800000;
-    y = 64'hB930008001FFFFFF;
-    z = 64'h43FFFFFFFFFFFF83;
-    ans = 64'h43FFFFFFFFFFFF83;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"380679\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h7FF0000000000000;
-    z = 64'hBFD0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"381293\n");
-    end
-    x = 64'hBFC4EC65823F040A;
-    y = 64'h8DDFFFFFE0000400;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"381907\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'hFFD07FF7FFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"382521\n");
-    end
-    x = 64'h41BFFFFFF7FFF000;
-    y = 64'hC19E0AA274921E95;
-    z = 64'hC2CFFFFFFE001FFE;
-    ans = 64'hC36E12A26D0EE6FB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"383135\n");
-    end
-    x = 64'hBCF1FFFFFFFFFEFE;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'hBFF0000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"383749\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hFFF205635E5BC7FC;
-    z = 64'hC7F200000003FFFF;
-    ans = 64'hFFFA05635E5BC7FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"384363\n");
-    end
-    x = 64'h41CFFFFFFFEFFFE0;
-    y = 64'h8000000000000001;
-    z = 64'h41D1CDB29820C684;
-    ans = 64'h41D1CDB29820C684;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"384977\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hC80FFFF000400000;
-    z = 64'h0010000000000001;
-    ans = 64'h882FFFF000400002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"385591\n");
-    end
-    x = 64'h41DFFFFBFFFFFFFF;
-    y = 64'hFEB3FFFFFFFFFFFF;
-    z = 64'h39BEFFFFFFF80000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"386205\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"386819\n");
-    end
-    x = 64'h43D4347C467523C5;
-    y = 64'h3CF0003FFFFFFFF7;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h4350000000001434;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"387433\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h8010000000000001;
-    z = 64'hC1D0E21DDC57C6F2;
-    ans = 64'hC1D0E21DDC57C6F2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"388047\n");
-    end
-    x = 64'h3FAEC83956AF6BDA;
-    y = 64'h47EFFFFFFFF007FF;
-    z = 64'h2DBBA7D5393B1408;
-    ans = 64'h47AEC83956A00F6E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"388661\n");
-    end
-    x = 64'hBFB543040DD1458A;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"389275\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hD5687D0C01D0A5C0;
-    z = 64'hC37FFFFFFDFFFDFE;
-    ans = 64'hC37FFFFFFDFFFDFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"389889\n");
-    end
-    x = 64'hC03DB75E6B3453F3;
-    y = 64'hBCA0000000000000;
-    z = 64'hC56FFBFFEFFFFFFE;
-    ans = 64'hC56FFBFFEFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"390503\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h437FFFFF3FFFFFFF;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h039FFFFF40000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"391117\n");
-    end
-    x = 64'h42170719F6674DF0;
-    y = 64'hBFCFF800000003FF;
-    z = 64'h41D0007F7FFFFFFF;
-    ans = 64'hC1F301384FE9B6FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"391731\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h8020000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"392345\n");
-    end
-    x = 64'h3FBFFFFE01FFFFFF;
-    y = 64'hBEBFFFFFFFF00800;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFFFFF00000FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"392959\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hBFD0000000000000;
-    z = 64'h41E0008000000002;
-    ans = 64'h41E0008000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"393573\n");
-    end
-    x = 64'h3FB11BFBA3DA9D75;
-    y = 64'hCF2FFFFF81FFFFFF;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hCEF11BFB607C6E9F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"394187\n");
-    end
-    x = 64'hC730000400000003;
-    y = 64'hBFD0000000000001;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'h4710000400000004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"394801\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h414FF0000000001F;
-    z = 64'h3FFBFFFFFFFFFEFE;
-    ans = 64'h3FFBFFFFFFFFFEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"395415\n");
-    end
-    x = 64'h41D00FFFFFFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h3FF6FFBCCC05FB7F;
-    ans = 64'hC1C00FFFFF480218;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"396029\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h7FE40000003FFFFE;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"396643\n");
-    end
-    x = 64'h5B31FBFFFFFFFFFE;
-    y = 64'h401001FFFFFFFFF6;
-    z = 64'h1150000FFFF7FFFE;
-    ans = 64'h5B51FE3F7FFFFFF3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"397257\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hBFE0000000000001;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h8017FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"397871\n");
-    end
-    x = 64'h41DFFFDF7FFFFFFF;
-    y = 64'hC6B0001007FFFFFE;
-    z = 64'h4010000000000000;
-    ans = 64'hC89FFFFF8FDF6FBB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"398485\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hCE2FFFEFFFFFFC00;
-    ans = 64'hCE2FFFEFFFFFFC00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"399099\n");
-    end
-    x = 64'hBFFFFFFFAFFFFFFE;
-    y = 64'hC340400000FFFFFF;
-    z = 64'hBF0FFFBFFFF80000;
-    ans = 64'h43503FFFD85FFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"399713\n");
-    end
-    x = 64'h3FCB24DCD9C1D121;
-    y = 64'hBFF0000000000000;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFDD926E6CE0E890;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"400327\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hC1CFFF7FFFFFFE00;
-    z = 64'h3FE00000003FFC00;
-    ans = 64'h3FE00000003FFC00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"400941\n");
-    end
-    x = 64'hBE1000003FFFFFBF;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hC34FF000003FFFFE;
-    ans = 64'hC34FF000003FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"401555\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h657003FFFFFFFC00;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"402169\n");
-    end
-    x = 64'h000B911E4CBDACCE;
-    y = 64'h39804000000003FF;
-    z = 64'h00139BDEF80EC19D;
-    ans = 64'h00139BDEF80EC19D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"402783\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hC000000000000000;
-    z = 64'h8000000000000000;
-    ans = 64'h8020000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"403397\n");
-    end
-    x = 64'h402FFFFFFC003FFE;
-    y = 64'hFFDF800010000000;
-    z = 64'h4000000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"404011\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h3FC0003FFFFF7FFF;
-    ans = 64'h3FC0003FFFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"404625\n");
-    end
-    x = 64'hFFE00000000010FE;
-    y = 64'h94432AB61CDBA523;
-    z = 64'h3E3BFFFFFFFFBFFE;
-    ans = 64'h54332AB61CDBB97E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"405239\n");
-    end
-    x = 64'h178FFFFFFFEFDFFE;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"405853\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h41EFFFFFFFFFFF7F;
-    z = 64'h47FFFFFFFFFFFFC1;
-    ans = 64'h47FFFFFFFFFFFFC1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"406467\n");
-    end
-    x = 64'h3CAFFFDBFFFFFFFF;
-    y = 64'hC010000000000001;
-    z = 64'h41D000FC00000000;
-    ans = 64'h41D000FC00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"407081\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hB7F989C602E18CB6;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"407695\n");
-    end
-    x = 64'hC0068C39C8421A45;
-    y = 64'h3EF00000207FFFFE;
-    z = 64'hBFD000000003FFBF;
-    ans = 64'hBFD000B461D3B036;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"408309\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"408923\n");
-    end
-    x = 64'hC1DFFF6FFFFFFFFF;
-    y = 64'hBB80000000000102;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h40000000000007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"409537\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hC340000000000001;
-    z = 64'h3FCFFFFEFFFFDFFE;
-    ans = 64'h3FCFFFFEFFFFDFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"410151\n");
-    end
-    x = 64'h3C7FFFFFF8008000;
-    y = 64'hC806EE1414AFC71A;
-    z = 64'h3D10D39F6CFAD054;
-    ans = 64'hC496EE140EF49DCD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"410765\n");
-    end
-    x = 64'h3E212A83DE6986F5;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'hC1812A83DE6986F4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"411379\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h3FE00000201FFFFF;
-    z = 64'h3FEFFFFFFF8000FF;
-    ans = 64'h3FEFFFFFFF8000FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"411993\n");
-    end
-    x = 64'h4807FFFDFFFFFFFE;
-    y = 64'hFFE0000000000000;
-    z = 64'h45B00000100003FF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"412607\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hC1DFFFFFC00FFFFF;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"413221\n");
-    end
-    x = 64'h4C90080000007FFF;
-    y = 64'h4180007DFFFFFFFF;
-    z = 64'hB7FFFCFFFFFFFFFF;
-    ans = 64'h4E20087E3F008002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"413835\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"414449\n");
-    end
-    x = 64'hC67D0752856A715F;
-    y = 64'hB2E000000BFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h3FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"415063\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hD5900001FFFF7FFF;
-    ans = 64'hD5900001FFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"415677\n");
-    end
-    x = 64'h401FFF8003FFFFFF;
-    y = 64'hFFEFFFFFFFFDFFFF;
-    z = 64'hBFBFF7FFFFFFEFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"416291\n");
-    end
-    x = 64'h383FE00000001FFF;
-    y = 64'hFFF0000000000001;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"416905\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h403FFFFBFFFFE000;
-    z = 64'hCC7DFFFFFFFFBFFE;
-    ans = 64'hCC7DFFFFFFFFBFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"417519\n");
-    end
-    x = 64'h47EFF87FFFFFFFFE;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h00080001FFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"418133\n");
-    end
-    x = 64'h0010000000000001;
-    y = 64'h3FD43FFFFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"418747\n");
-    end
-    x = 64'h41E1FFFFFFFFFFEF;
-    y = 64'hF3303EFFFFFFFFFF;
-    z = 64'h46BFFFFFFF001FFF;
-    ans = 64'hF52246DFFFFFFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"419361\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h0000000000000001;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"419975\n");
-    end
-    x = 64'h3FD007FFFF7FFFFE;
-    y = 64'h3FFFFFFFFBFFFEFF;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FF003FFFEBF7FBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"420589\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h396C5680AC81324C;
-    ans = 64'h396C5680AC81324C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"421203\n");
-    end
-    x = 64'hBFF0000000004006;
-    y = 64'h3800002000000006;
-    z = 64'hA7700FF000000000;
-    ans = 64'hB80000200000400D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"421817\n");
+    	$fwrite(fp,"376073\n");
     end
-    x = 64'hA2EFFFFFFFF7FC00;
-    y = 64'h0010000000000000;
-    z = 64'h8000000000000000;
-    ans = 64'h8000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h43F2B50D2D1063E9;
+    ReadData2E = 64'h3F24B8494F924E33;
+    ReadData3E = 64'hC34FFD7FFFFFFFFF;
+    ans = 64'hC349EF0DEE440A1B;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"422431\n");
+    	$fwrite(fp,"376379\n");
     end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hDE40000000140000;
-    z = 64'h3E17FFFEFFFFFFFF;
-    ans = 64'h3E17FFFEFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h37E7DAF9073C2293;
+    ans = 64'h37E7DAF9073C2293;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"423045\n");
+    	$fwrite(fp,"376685\n");
     end
-    x = 64'hBFF000007FEFFFFF;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hBF7000FFBFFFFFFF;
-    ans = 64'hBF7000FFBFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFE7E8F25A9B01D1;
+    ReadData2E = 64'h8EF00000000C0000;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"423659\n");
+    	$fwrite(fp,"376991\n");
     end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h5FF000000000FF80;
-    z = 64'hC010000000000000;
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'hC010000000000000;
     ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"424273\n");
+    	$fwrite(fp,"377297\n");
     end
-    x = 64'h37F2018CDBC5E6EC;
-    y = 64'h3FD010007FFFFFFF;
-    z = 64'h3FDF87FFFFFFFFFF;
-    ans = 64'h3FDF87FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h000ABEC8547943F5;
+    ReadData2E = 64'hC34FF7FFFFFFEFFE;
+    ReadData3E = 64'h382001FFFF7FFFFF;
+    ans = 64'h382001FFFF7FFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"424887\n");
+    	$fwrite(fp,"377603\n");
     end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h3CA0000000000000;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h77C007F7FFFFFFFE;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hBCA0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"425501\n");
+    	$fwrite(fp,"377909\n");
     end
-    x = 64'h434040000000003E;
-    y = 64'hB81FFFFFFF7FFFFF;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h41E0001F7FFFFFFE;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'h41DFFFFEFFFFFFFF;
+    ans = 64'h4540001F7FFFFFFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"426115\n");
+    	$fwrite(fp,"378215\n");
     end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h3CA0000000000001;
-    z = 64'h402FFFFFFEFFFF7F;
-    ans = 64'h402FFFFFFEFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBFEF5FFFFFFFFFFF;
+    ReadData3E = 64'h3FC0000000003FFB;
+    ans = 64'h3FC0000000003FFB;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"426729\n");
+    	$fwrite(fp,"378521\n");
     end
-    x = 64'hC3E001FFFFFBFFFF;
-    y = 64'hBFCFFFFC003FFFFE;
-    z = 64'h3FD000007FFFF800;
-    ans = 64'h43C001FDFFDC03FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"427343\n");
-    end
-    x = 64'hB7F00001FEFFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"427957\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h401FFFFBFFFFFFFE;
-    z = 64'h7FEDF7FFFFFFFFFE;
-    ans = 64'h7FEDF7FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"428571\n");
-    end
-    x = 64'hB97000010000FFFF;
-    y = 64'h3FD0000000000001;
-    z = 64'hCDABA05ECB7D8187;
-    ans = 64'hCDABA05ECB7D8187;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"429185\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h800FFFFBFC000000;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"429799\n");
-    end
-    x = 64'hBFDC8AD94D9D9EA7;
-    y = 64'hBF1FFFFFDFFF0000;
-    z = 64'hC1E04000001FFFFE;
-    ans = 64'hC1E04000001FFF8C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"430413\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"431027\n");
-    end
-    x = 64'h403EE56F7508D6C4;
-    y = 64'h3E2FFFBFFFFFFF7F;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3E7EE531AB29EC36;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"431641\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h3FE0000000000000;
-    z = 64'h410F7FFFFFFFFBFF;
-    ans = 64'h410F7FFFFFFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"432255\n");
-    end
-    x = 64'hBFFFFFFF9FFFFFFF;
-    y = 64'h3FC000BFFFFFFFFE;
-    z = 64'h47FE4FE7FC5CA94B;
-    ans = 64'h47FE4FE7FC5CA94B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"432869\n");
-    end
-    x = 64'h3EF00000000007FD;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"433483\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h8000ADABC1083601;
-    z = 64'h7A500003FFFFFFDF;
-    ans = 64'h7A500003FFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"434097\n");
-    end
-    x = 64'hC3C100000003FFFF;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h80001FFFFFFFFEFF;
-    ans = 64'hC3C100000003FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"434711\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hBD5000000FDFFFFE;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"435325\n");
-    end
-    x = 64'hC14EFFFFFFFFFFF0;
-    y = 64'hBB7F00000007FFFE;
-    z = 64'h401FFFEFFFFFFFF6;
-    ans = 64'h401FFFEFFFFFFFF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"435939\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"436553\n");
-    end
-    x = 64'hBD8FE00020000000;
-    y = 64'h43FBD1AA550D93D7;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'hC19BB5D8C68A3098;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"437167\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h37F3FFFFFBFFFFFE;
-    ans = 64'h37F3FFFFFBFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"437781\n");
-    end
-    x = 64'h7FEE640EDD7D325B;
-    y = 64'hBF9FFEFFFFF80000;
-    z = 64'hC6FFC00000000000;
-    ans = 64'hFF9E631BBCFEAD6E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"438395\n");
-    end
-    x = 64'hC00000000FFFDFFF;
-    y = 64'h4000000000000001;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"439009\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hC7FFFFFF00000004;
-    z = 64'h3F771D032C61EC36;
-    ans = 64'h3F771D032C61EC36;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"439623\n");
-    end
-    x = 64'h41E76CC19771603B;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hCD70020000800000;
-    ans = 64'hCD70020000800000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"440237\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h3FEDFFFFFFFFFFF0;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"440851\n");
-    end
-    x = 64'h001FFFFFFFFFFF02;
-    y = 64'h39FEC6BF7D1B70B5;
-    z = 64'h9DC000000001FFBE;
-    ans = 64'h9DC000000001FFBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"441465\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h4010000000000001;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"442079\n");
-    end
-    x = 64'h7FE00000000007F7;
-    y = 64'hCBDFFFFFFFFFFFFF;
-    z = 64'h0010000000000000;
+    ReadData1E = 64'hC1CFF80000007FFF;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
     ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"442693\n");
+    	$fwrite(fp,"378827\n");
     end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h41CFFFFFFFF07FFF;
-    ans = 64'h41CFFFFFFFF07FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFE5E5EE64C01393;
+    ReadData2E = 64'hBFD00000000BFFFF;
+    ReadData3E = 64'h3FC0000100001FFF;
+    ans = 64'h7FC5E5EE64D08004;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"443307\n");
+    	$fwrite(fp,"379133\n");
     end
-    x = 64'h40B318ECB7EB7D19;
-    y = 64'h3FF51305D82EA9EE;
-    z = 64'hC3FFBFFFFFFFFFBF;
-    ans = 64'hC3FFBFFFFFFFFFBD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'h499FFF7FFFFFFFEF;
+    ans = 64'h499FFF7FFFFFFFEF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"443921\n");
+    	$fwrite(fp,"379439\n");
     end
-    x = 64'h3FD65C4920561A4B;
-    y = 64'h4340000000000000;
-    z = 64'h4340000000000000;
-    ans = 64'h4345971248158693;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"444535\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hC002673D3605EDFC;
-    z = 64'hFFF0001000FFFFFF;
-    ans = 64'hFFF8001000FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"445149\n");
-    end
-    x = 64'h43C000020000003E;
-    y = 64'h4340000000000001;
-    z = 64'hC00000003FFFFFBF;
-    ans = 64'h471000020000003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"445763\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hB7EFFFFFFFFFFF80;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"446377\n");
-    end
-    x = 64'h42DFFFFFFFE7FFFF;
-    y = 64'h37ED7BB22AE6852A;
-    z = 64'hBFCFFFFFFFFFFFEF;
-    ans = 64'hBFCFFFFFFFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"446991\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h7FE0000000000000;
-    z = 64'h3FF0000000000000;
-    ans = 64'h4014000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"447605\n");
-    end
-    x = 64'h802000003FFFFBFF;
-    y = 64'hC3CFFFFFFFFFFFD7;
-    z = 64'h0000000000000001;
-    ans = 64'h040000003FFFFBEA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"448219\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h7FE0000000000001;
-    z = 64'h43E3FFFF80000000;
-    ans = 64'h43E3FFFF80000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"448833\n");
-    end
-    x = 64'hC3423795C42FF6F8;
-    y = 64'hC070043FFFFFFFFF;
-    z = 64'hBFDCEB966144812B;
-    ans = 64'h43C23C6C87F813B4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"449447\n");
-    end
-    x = 64'h400FFFF87FFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h4010000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"450061\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h413C7FD643DAF76F;
-    z = 64'hC05D90A520010B43;
-    ans = 64'hC05D90A520010B43;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"450675\n");
-    end
-    x = 64'h4220040000080000;
-    y = 64'h7FF0000000000000;
-    z = 64'hB7F2E64B75544CD9;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"451289\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h40E00000002FFFFE;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"451903\n");
-    end
-    x = 64'h37F00000000017FE;
-    y = 64'hBFDC9E6C8A133CA5;
-    z = 64'h39EEFFFFFFFFFFFF;
-    ans = 64'h39EEFFFFFFF1B0C9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"452517\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h3FE0000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"453131\n");
-    end
-    x = 64'hC130000000007FDF;
-    y = 64'h3CABD2A0BF65E45F;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"453745\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h8000000000000000;
-    z = 64'hC1CFB2531402EC4E;
-    ans = 64'hC1CFB2531402EC4E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"454359\n");
-    end
-    x = 64'hB29C35CB8E00D8E6;
-    y = 64'hC3402000000001FF;
-    z = 64'hC0F7FBFFFFFFFFFE;
-    ans = 64'hC0F7FBFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"454973\n");
-    end
-    x = 64'hBFAFFFFEFFFFFFC0;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"455587\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h4800040000003FFE;
-    z = 64'hBFED31C40B4B727C;
-    ans = 64'hBFED31C40B4B727C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"456201\n");
-    end
-    x = 64'h402206EC0CADFB89;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"456815\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h3F0FDFFFFEFFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"457429\n");
-    end
-    x = 64'h400FF40000000000;
-    y = 64'hC3E00FFFEFFFFFFF;
-    z = 64'h229FEFFFFFFFF7FF;
-    ans = 64'hC40009F9F005FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"458043\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"458657\n");
-    end
-    x = 64'h916FFFFFFFDDFFFF;
-    y = 64'h3FF3FFFFFEFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"459271\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h4664AF10B2B4831C;
-    ans = 64'h4664AF10B2B4831C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"459885\n");
-    end
-    x = 64'hB03000000DFFFFFF;
-    y = 64'h41E0040000000200;
-    z = 64'hC034966F42C45187;
-    ans = 64'hC034966F42C45187;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"460499\n");
-    end
-    x = 64'hC32BC7B859BF9991;
-    y = 64'hBCA0000000000001;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h400378F70B37F331;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"461113\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hBFE000007DFFFFFE;
-    z = 64'hBCAFFFFFFFFFFE3F;
-    ans = 64'hBCAFFFFFFFFFFE3F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"461727\n");
-    end
-    x = 64'hC0200000401FFFFF;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h43FFF7FFFFFFFF7F;
-    ans = 64'h43FFF7FFFFFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"462341\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h41F5D9F10DF04721;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h0225D9F10DE04720;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"462955\n");
-    end
-    x = 64'h780C28A279108114;
-    y = 64'h65C7CB88671E9840;
-    z = 64'hC8004B04A2AE6C6C;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"463569\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hBFD0000000000001;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"464183\n");
-    end
-    x = 64'h4023FFFFFFFC0000;
-    y = 64'hC02FFFFFFFDDFFFF;
-    z = 64'hFFE0000000000000;
+    ReadData1E = 64'hBFF95C149819D013;
+    ReadData2E = 64'h3FEFFFFFFFE0000F;
+    ReadData3E = 64'hFFE0000000000000;
     ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"464797\n");
+    	$fwrite(fp,"379745\n");
     end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hC13FFDFFFFFFFFDF;
-    ans = 64'hC13FFDFFFFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'h4018000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"465411\n");
+    	$fwrite(fp,"380051\n");
     end
-    x = 64'hBFFFE003FFFFFFFE;
-    y = 64'h3FD0800000000000;
-    z = 64'h380FFFFBFFFFFFFF;
-    ans = 64'hBFE06F820FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h98FFFF00000001FF;
+    ReadData2E = 64'h76A000FBFFFFFFFF;
+    ReadData3E = 64'h3CA0000000400FFE;
+    ans = 64'hCFB0007BF82000FF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"466025\n");
+    	$fwrite(fp,"380357\n");
     end
-    x = 64'hBFE00000080003FF;
-    y = 64'hBFE0000000000000;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF4000002000100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h43CF7FFFFFFFDFFE;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h03EF7FFFFFFFE000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"466639\n");
+    	$fwrite(fp,"380663\n");
     end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h47FFFFFFFFFFEBFE;
-    z = 64'h3F38CD81E06C497A;
-    ans = 64'h3F38CD81E06C497A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFEEFFFDFFFFFFFE;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hC3DF3A8CBF006383;
+    ans = 64'hFFEEFFFDFFFFFFFC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"467253\n");
+    	$fwrite(fp,"380969\n");
     end
-    x = 64'hB810000000000803;
-    y = 64'hBFE0000000000001;
-    z = 64'hC3DDFFFFFFFFFFBE;
-    ans = 64'hC3DDFFFFFFFFFFBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hF80FFFFFFFC00001;
+    ReadData3E = 64'hC8800000007FDFFE;
+    ans = 64'hC8800000007FDFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"467867\n");
+    	$fwrite(fp,"381275\n");
     end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hB80FFFFFFFF7BFFF;
-    z = 64'h8010000000000000;
-    ans = 64'h8010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFEFFFF03FFFFFFF;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"468481\n");
+    	$fwrite(fp,"381581\n");
     end
-    x = 64'h3EFFFFFFFFEFFF00;
-    y = 64'h400000000000400F;
-    z = 64'hC8000200003FFFFF;
-    ans = 64'hC8000200003FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBD848F6BEB745C8A;
+    ReadData2E = 64'hBFB82E20E6DA10F1;
+    ReadData3E = 64'h47E2000FFFFFFFFF;
+    ans = 64'h47E2000FFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"469095\n");
+    	$fwrite(fp,"381887\n");
     end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hBFF0000000000000;
-    z = 64'h3CA0000000000000;
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'hB430000000100080;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"382193\n");
+    end
+    ReadData1E = 64'hBF8BF116CF9EB336;
+    ReadData2E = 64'hBFF000000200007F;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"382499\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"382805\n");
+    end
+    ReadData1E = 64'h002FFFFFFFFFF7FF;
+    ReadData2E = 64'h3FE6BFDF70E60FB1;
+    ReadData3E = 64'h41CFFE07FFFFFFFF;
+    ans = 64'h41CFFE07FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"383111\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h43403FFFFFFEFFFF;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'h03603FFFFFFF0000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"383417\n");
+    end
+    ReadData1E = 64'h3800000800000003;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h4020AE1F9ECA9031;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"383723\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBFCFB217BCF730CB;
+    ReadData3E = 64'hBF1FF7FFE0000000;
+    ans = 64'hBF1FF7FFE0000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"384029\n");
+    end
+    ReadData1E = 64'h41786956587A01AC;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"384335\n");
+    end
+    ReadData1E = 64'hC1EFFFFBFFFEFFFF;
+    ReadData2E = 64'hB80FFDFFFFFFF7FF;
+    ReadData3E = 64'h41EE329F77C38BD2;
+    ans = 64'h41EE329F77C38BD2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"384641\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'hC005A4CE9C323304;
+    ans = 64'hC005A4CE9C323304;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"384947\n");
+    end
+    ReadData1E = 64'hC3DD085B6A950C5E;
+    ReadData2E = 64'h000800000000001F;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"385253\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'h3FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"385559\n");
+    end
+    ReadData1E = 64'hA7571911431E5523;
+    ReadData2E = 64'hC3D000000010FFFF;
+    ReadData3E = 64'h3E0000000000021E;
+    ans = 64'h3E0000000000021E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"385865\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h43D0000800003FFE;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"386171\n");
+    end
+    ReadData1E = 64'h3FCFFBFBFFFFFFFE;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'hC1E000000000FFE0;
+    ans = 64'hC1E000000000FFE0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"386477\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3FCF800000000004;
+    ReadData3E = 64'hC3EFFFFFFFFFFD00;
+    ans = 64'hC3EFFFFFFFFFFD00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"386783\n");
+    end
+    ReadData1E = 64'hBFF84430474AABF1;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"387089\n");
+    end
+    ReadData1E = 64'hBE9D7FFFFFFFFFFF;
+    ReadData2E = 64'hC030007FFFFBFFFF;
+    ReadData3E = 64'hC963F3DF40853CC4;
+    ans = 64'hC963F3DF40853CC4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"387395\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'hD7B00000000003FB;
+    ans = 64'hD7B00000000003FB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"387701\n");
+    end
+    ReadData1E = 64'hC1C1000000000200;
+    ReadData2E = 64'hFFD000200007FFFE;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"388007\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hBFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"388313\n");
+    end
+    ReadData1E = 64'h9E5FF00000004000;
+    ReadData2E = 64'h54E01FFFFFFFFDFF;
+    ReadData3E = 64'h00099A5422D8B766;
+    ans = 64'hB35017F000001E40;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"388619\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hCE80000018000000;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"388925\n");
+    end
+    ReadData1E = 64'hB81FC0000000003F;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'h73FFFFFFBFFFFF80;
+    ans = 64'h73FFFFFFBFFFFF80;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"389231\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hFFD001FFFFFFFFF7;
+    ReadData3E = 64'h415C71AEA4B8E680;
+    ans = 64'h415C71AE64B0E680;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"389537\n");
+    end
+    ReadData1E = 64'h47F8A277FB0CC05C;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hBCAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"389843\n");
+    end
+    ReadData1E = 64'h3CA7C32F64B84C77;
+    ReadData2E = 64'h281FFFFEDFFFFFFF;
+    ReadData3E = 64'h2E3CF9805BD36589;
+    ans = 64'h2E3CF9805BD36589;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"390149\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'hC20001FFFF000000;
+    ans = 64'hC20001FFFF000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"390455\n");
+    end
+    ReadData1E = 64'hC11FFF7FFFFEFFFF;
+    ReadData2E = 64'h43FC9E1AE158F437;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hC52C9DA868EC89E1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"390761\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"391067\n");
+    end
+    ReadData1E = 64'hBFD04000007FFFFF;
+    ReadData2E = 64'hA8BFFFFFFFFF7FFA;
+    ReadData3E = 64'h401338B91A01C053;
+    ans = 64'h401338B91A01C053;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"391373\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC00FFFFFFFBFFFE0;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"391679\n");
+    end
+    ReadData1E = 64'hFFDFFFFFFEFFFEFF;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'hC7FFEFFFFFFFFBFF;
+    ans = 64'h7C8FFFFFFEFFFF01;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"391985\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3FE0000000000201;
+    ReadData3E = 64'hBFDA78ED1BAFDD0A;
+    ans = 64'hBFDA78ED1BAFDD0A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"392291\n");
+    end
+    ReadData1E = 64'h401F000002000000;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'hBCDF000001FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"392597\n");
+    end
+    ReadData1E = 64'hC1E00001FFFFFFBE;
+    ReadData2E = 64'h3FB0000400007FFF;
+    ReadData3E = 64'hC030000000000008;
+    ans = 64'hC1A000062000FFBD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"392903\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'h4DB0005FFFFFFFFF;
+    ans = 64'h4DB0005FFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"393209\n");
+    end
+    ReadData1E = 64'h403FFFFFFFFB8000;
+    ReadData2E = 64'hC1D000101FFFFFFE;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'hC22000101FFBBFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"393515\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hBCAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"393821\n");
+    end
+    ReadData1E = 64'hC07FF7FFFFF7FFFF;
+    ReadData2E = 64'h7FEFFFC000FFFFFF;
+    ReadData3E = 64'hBEA0400000000006;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"394127\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC012F769A2FB5162;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h434FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"394433\n");
+    end
+    ReadData1E = 64'hC1E000000000001D;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'hC1F3EE27F9A3D71F;
+    ans = 64'hC1F1EE27F9A3D71B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"394739\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h37EFFFF0FFFFFFFE;
+    ReadData3E = 64'hBBB00008FFFFFFFF;
+    ans = 64'hBBB00008FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"395045\n");
+    end
+    ReadData1E = 64'h8002000000000000;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h800F800000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"395351\n");
+    end
+    ReadData1E = 64'h408C252230659285;
+    ReadData2E = 64'h3FEFFFE000000001;
+    ReadData3E = 64'hFFEDFFFFFFFFFF7E;
+    ans = 64'hFFEDFFFFFFFFFF7E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"395657\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'h58CFE0007FFFFFFE;
+    ans = 64'h58CFE0007FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"395963\n");
+    end
+    ReadData1E = 64'h233FFFFFC0000080;
+    ReadData2E = 64'hC03100000001FFFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hBFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"396269\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h0017FFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"396575\n");
+    end
+    ReadData1E = 64'hC00F7FFFFFFF0000;
+    ReadData2E = 64'h41FFFFFFFFFE001F;
+    ReadData3E = 64'hC3CFFFFFFFFFEC00;
+    ans = 64'hC3D0000001F7F600;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"396881\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h8950000007DFFFFE;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hC01FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"397187\n");
+    end
+    ReadData1E = 64'h43C0400000003FFE;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'h001000003FFFFF7F;
+    ans = 64'hC3B0400000003FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"397493\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hB2659A07DA522AC2;
+    ReadData3E = 64'h4D2000FFBFFFFFFF;
+    ans = 64'h4D2000FFBFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"397799\n");
+    end
+    ReadData1E = 64'h47EC1BAD2B3E6CDC;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'hC7DC1BAD2B3E6CDE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"398105\n");
+    end
+    ReadData1E = 64'h3FEFFFF7FFFFFFF6;
+    ReadData2E = 64'hB7FFFFFFFF0003FF;
+    ReadData3E = 64'h800FFFFFFFFFDDFE;
+    ans = 64'hB7FFFFF7FF000435;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"398411\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'hBFC000000000A000;
+    ans = 64'hBFC000000000A000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"398717\n");
+    end
+    ReadData1E = 64'h002FF7BFFFFFFFFE;
+    ReadData2E = 64'h800B7AD760176442;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h3FDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"399023\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h8020000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"399329\n");
+    end
+    ReadData1E = 64'h5D200010000001FF;
+    ReadData2E = 64'h381F000080000000;
+    ReadData3E = 64'h486FFFFFFFEFFF80;
+    ans = 64'h554F001F800083DE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"399635\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h4034720DB721EB5E;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"399941\n");
+    end
+    ReadData1E = 64'h40000000801FFFFF;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h41EC000000008000;
+    ans = 64'h41EBFFFFFFC07FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"400247\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h40E0020001000000;
+    ReadData3E = 64'h4016F0BC0E532E91;
+    ans = 64'h4016F0BC0E532E91;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"400553\n");
+    end
+    ReadData1E = 64'hC24FFFFFBFFFBFFE;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"400859\n");
+    end
+    ReadData1E = 64'hC00816F876A3A39B;
+    ReadData2E = 64'h801FFFFFFF0007FF;
+    ReadData3E = 64'h3FCFFF0001FFFFFE;
+    ans = 64'h3FCFFF0001FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"401165\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'hC5A0007DFFFFFFFE;
+    ans = 64'hC5A0007DFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"401471\n");
+    end
+    ReadData1E = 64'h3FFFFFFFBFEFFFFF;
+    ReadData2E = 64'hC0A52E0A869D4883;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'hC0B52E4A5C369C70;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"401777\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'h8020000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"402083\n");
+    end
+    ReadData1E = 64'hA350000021FFFFFF;
+    ReadData2E = 64'hA66FF8000000000F;
+    ReadData3E = 64'hC3D0080000001000;
+    ans = 64'hC3D0080000001000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"402389\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hB7E0022000000000;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"402695\n");
+    end
+    ReadData1E = 64'h043FFFFBFFFFFFFF;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h278F80000000003F;
+    ans = 64'h278F80000000003F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"403001\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h414AC3E82996F770;
+    ReadData3E = 64'h3F10000003FFFF7E;
+    ans = 64'h3F10000003FFFF7E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"403307\n");
+    end
+    ReadData1E = 64'hC3D013FFFFFFFFFF;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"403613\n");
+    end
+    ReadData1E = 64'hB7F9E772425B7128;
+    ReadData2E = 64'hBFAFFDC000000000;
+    ReadData3E = 64'h380FFFFFFFFBFFFD;
+    ans = 64'h381067967FEF4B19;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"403919\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'hFFFFBEFFFFFFFFFF;
+    ans = 64'hFFFFBEFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"404225\n");
+    end
+    ReadData1E = 64'hB7E37A866D226CAF;
+    ReadData2E = 64'h3FD49B0AB002569D;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'h3CA0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"404531\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"404837\n");
+    end
+    ReadData1E = 64'h43FA57E9C5624B8A;
+    ReadData2E = 64'hC800000FFFFF7FFE;
+    ReadData3E = 64'h4342599B7B2573CC;
+    ans = 64'hCC0A58041D4B3E2A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"405143\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBF800000000407FF;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h3FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"405449\n");
+    end
+    ReadData1E = 64'hC3E0000008FFFFFF;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h47403FFFDFFFFFFF;
+    ans = 64'h47403FFFE0000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"405755\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3E50FFFFFFFFFFF6;
+    ReadData3E = 64'h467001F7FFFFFFFF;
+    ans = 64'h467001F7FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"406061\n");
+    end
+    ReadData1E = 64'h7FD000000FFFFFFA;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'hFFE000001FFFFFF2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"406367\n");
+    end
+    ReadData1E = 64'h7FECAFD59CB7B74C;
+    ReadData2E = 64'h41DBCBEB843B4CF3;
+    ReadData3E = 64'h41F8A2957B307164;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"406673\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'hC340000004080000;
+    ans = 64'hC340000004080000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"406979\n");
+    end
+    ReadData1E = 64'hB81FF80000000001;
+    ReadData2E = 64'hC1C71750D077617C;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h39F7118AFC4343A4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"407285\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"407591\n");
+    end
+    ReadData1E = 64'h802FFFFFFFFFFA00;
+    ReadData2E = 64'h37E6AE1D90D70705;
+    ReadData3E = 64'hBFDFFF77FFFFFFFE;
+    ans = 64'hBFDFFF77FFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"407897\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC1C00203FFFFFFFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hBFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"408203\n");
+    end
+    ReadData1E = 64'h43EFFBFFFFFFDFFF;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'hC036CD7A7F9E1F02;
+    ans = 64'hC41FFBFFFFFFDFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"408509\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBFE280673AD588A9;
+    ReadData3E = 64'h4025DE3CDA0994EF;
+    ans = 64'h4025DE3CDA0994EF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"408815\n");
+    end
+    ReadData1E = 64'hC3EFFFF0000FFFFF;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'h441FFF70000FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"409121\n");
+    end
+    ReadData1E = 64'h4032E061B83BDA94;
+    ReadData2E = 64'hC8F000000001FBFF;
+    ReadData3E = 64'hBF4ED64192CA3998;
+    ans = 64'hC932E061B83E31E7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"409427\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'hE7C002000FFFFFFF;
+    ans = 64'hE7C002000FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"409733\n");
+    end
+    ReadData1E = 64'hC1E7545A88785004;
+    ReadData2E = 64'hC120007FFF800000;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'h431755152A91F0F2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"410039\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"410345\n");
+    end
+    ReadData1E = 64'hC2D91B69773500AA;
+    ReadData2E = 64'h40B1000000000006;
+    ReadData3E = 64'hFFDFFFFFFFE0007F;
+    ans = 64'hFFDFFFFFFFE0007F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"410651\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h4340000FFFDFFFFF;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h3FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"410957\n");
+    end
+    ReadData1E = 64'hBCAE912E62741E61;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'hBCAC430028149BD0;
+    ans = 64'h3FFE912E62741E62;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"411263\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC3EFFC0000000003;
+    ReadData3E = 64'h4031FFFFFFFDFFFF;
+    ans = 64'h4031FFFFFFFDFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"411569\n");
+    end
+    ReadData1E = 64'hC1C000000027FFFE;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h452000000027FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"411875\n");
+    end
+    ReadData1E = 64'hC0CFFF7FFBFFFFFF;
+    ReadData2E = 64'h7E000000FFFFFFFB;
+    ReadData3E = 64'h800FFFFC0003FFFE;
+    ans = 64'hFEDFFF81FBF7FFB5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"412181\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'h401FFFFFFFFE003E;
+    ans = 64'h401FFFFFFFFE003E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"412487\n");
+    end
+    ReadData1E = 64'hB8900000080007FF;
+    ReadData2E = 64'h433FE0000FFFFFFE;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'hBBDFE0001FF00FF4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"412793\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"413099\n");
+    end
+    ReadData1E = 64'hC174AF337885BA36;
+    ReadData2E = 64'h801FFFFFFFEFFFDF;
+    ReadData3E = 64'h41FBFFFFFFFFFFFC;
+    ans = 64'h41FBFFFFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"413405\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h001153E88EFDD9B6;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hBFD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"413711\n");
+    end
+    ReadData1E = 64'hBFD2000000FFFFFF;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hC16FFFFFFFFF7FEF;
+    ans = 64'h7FC2000001000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"414017\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h84D00001000000FE;
+    ReadData3E = 64'hC0500020000000FF;
+    ans = 64'hC0500020000000FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"414323\n");
+    end
+    ReadData1E = 64'hDE54CE8EEB63015D;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"414629\n");
+    end
+    ReadData1E = 64'hB2200027FFFFFFFF;
+    ReadData2E = 64'h47E1F36BF0B15ECA;
+    ReadData3E = 64'h407FFFFFFFFFF007;
+    ans = 64'h407FFFFFFFFFF007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"414935\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h43D00FFFFFFFFEFF;
+    ans = 64'h43D00FFFFFFFFEFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"415241\n");
+    end
+    ReadData1E = 64'hC1EFBFF7FFFFFFFF;
+    ReadData2E = 64'hC032BA8DF73A392C;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"415547\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h400FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"415853\n");
+    end
+    ReadData1E = 64'h00000000000C0000;
+    ReadData2E = 64'hBE80000FFFEFFFFE;
+    ReadData3E = 64'h763FFFFC07FFFFFE;
+    ans = 64'h763FFFFC07FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"416159\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hCF531BF125DB15C1;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'h3CAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"416465\n");
+    end
+    ReadData1E = 64'hC1CFFFFEEFFFFFFF;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'h474E6EDD61B287DA;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"416771\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hBFF0004000000040;
+    ReadData3E = 64'h480FFDFFFFFFFFDE;
+    ans = 64'h480FFDFFFFFFFFDE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"417077\n");
+    end
+    ReadData1E = 64'h3CA0000100000100;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"417383\n");
+    end
+    ReadData1E = 64'h8017C536DDFF8DDC;
+    ReadData2E = 64'h40B0003FFFFFFFDF;
+    ReadData3E = 64'h43E1000000000007;
+    ans = 64'h43E1000000000007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"417689\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h434100000000000F;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"417995\n");
+    end
+    ReadData1E = 64'hC03FFC0010000000;
+    ReadData2E = 64'h354FFFFFFDFFFFFE;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"418301\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"418607\n");
+    end
+    ReadData1E = 64'hED20034307B6E182;
+    ReadData2E = 64'h3FDFFFFC000000FF;
+    ReadData3E = 64'hC1DDBCE05D5025DF;
+    ans = 64'hED100341074E810B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"418913\n");
+    end
+    ReadData1E = 64'h0010000000000001;
+    ReadData2E = 64'h3CA42E8DA0B707E4;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'h801FFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"419219\n");
+    end
+    ReadData1E = 64'hC0CF800000800000;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC0000002007FFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"419525\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBF00001003FFFFFF;
+    ReadData3E = 64'hC34FFC07FFFFFFFE;
+    ans = 64'hC34FFC07FFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"419831\n");
+    end
+    ReadData1E = 64'hBF91F142D19F36E5;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hBFF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"420137\n");
+    end
+    ReadData1E = 64'h7FFFFF00000007FF;
+    ReadData2E = 64'h3F0FFFFFFDFFFEFE;
+    ReadData3E = 64'hBFE4E89A16B1F0B7;
+    ans = 64'h7FFFFF00000007FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"420443\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'h4010001FFFFFFFFB;
+    ans = 64'h4010001FFFFFFFFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"420749\n");
+    end
+    ReadData1E = 64'h4030000207FFFFFF;
+    ReadData2E = 64'h3FB0000001000001;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"421055\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'h4000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"421361\n");
+    end
+    ReadData1E = 64'h000D9AB04F057759;
+    ReadData2E = 64'h8020000000007FFF;
+    ReadData3E = 64'h43BFFFFFFFFFFFFF;
+    ans = 64'h43BFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"421667\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBDAEFFFFFFFFEFFF;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'h000FFFFFFFFE1000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"421973\n");
+    end
+    ReadData1E = 64'h3D04003FFFFFFFFF;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h8010000FFFFFF000;
+    ans = 64'h8010000FFFFFEFD8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"422279\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC03FEFFFFFFFFF7F;
+    ReadData3E = 64'h40000010000001FE;
+    ans = 64'h40000010000001FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"422585\n");
+    end
+    ReadData1E = 64'hA1CFFFC0000FFFFF;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h3FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"422891\n");
+    end
+    ReadData1E = 64'hBFE0000000010200;
+    ReadData2E = 64'hBFDDE00000000000;
+    ReadData3E = 64'hC04F72F0FC0052B0;
+    ans = 64'hC04F5510FC0050CE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"423197\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'h40420003FFFFFFFF;
+    ans = 64'h40420003FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"423503\n");
+    end
+    ReadData1E = 64'h1FD0000000001010;
+    ReadData2E = 64'hF7E201FFFFFFFFFF;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'hD7C2020000001213;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"423809\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hBFF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"424115\n");
+    end
+    ReadData1E = 64'h806E1FFFFFFFFFFF;
+    ReadData2E = 64'h3FEFFFFFFEFBFFFF;
+    ReadData3E = 64'hFFFFFFFFFFFB8000;
+    ans = 64'hFFFFFFFFFFFB8000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"424421\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FF03FFFFFF7FFFF;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h7FF83FFFFFF7FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"424727\n");
+    end
+    ReadData1E = 64'hB21FFDFFFEFFFFFF;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFCFBFFFFFFFFFDF;
+    ans = 64'hBFCFBFFFFFFFFFDF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"425033\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC1B603569C15ABE9;
+    ReadData3E = 64'hC270000008000006;
+    ans = 64'hC270000008000006;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"425339\n");
+    end
+    ReadData1E = 64'hBF8007FFFFFFBFFE;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"425645\n");
+    end
+    ReadData1E = 64'hB8795CFD10295802;
+    ReadData2E = 64'h3940200000000FFF;
+    ReadData3E = 64'hDBC07FFFFFFFF800;
+    ans = 64'hDBC07FFFFFFFF800;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"425951\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'hBF9250BCC49C6F75;
+    ans = 64'hBF9250BCC49C6F75;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"426257\n");
+    end
+    ReadData1E = 64'hBF3FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FEFFFFE000003FF;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC010007FFFF80001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"426563\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h3FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"426869\n");
+    end
+    ReadData1E = 64'hC7E77FD7CFDA2EB7;
+    ReadData2E = 64'hC7EBFFFFFFFEFFFE;
+    ReadData3E = 64'h7FF512B59DBA0209;
+    ans = 64'h7FFD12B59DBA0209;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"427175\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3F9122AE3B5AC8CD;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"427481\n");
+    end
+    ReadData1E = 64'hC03FFFFFFFFFF00F;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'h002FFFFFFFFF5FFF;
+    ans = 64'hBCFFFFFFFFFFF00E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"427787\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC1F0000003FFFE00;
+    ReadData3E = 64'h41F00200000001FE;
+    ans = 64'h41F00200000001FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"428093\n");
+    end
+    ReadData1E = 64'hFFE20000000FFFFE;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'hFCA20000000FFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"428399\n");
+    end
+    ReadData1E = 64'h3C92000000000006;
+    ReadData2E = 64'h8023D9D6A90F4495;
+    ReadData3E = 64'hC1E0201FFFFFFFFF;
+    ans = 64'hC1E0201FFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"428705\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'hBF2CF30ABF2C898A;
+    ans = 64'hBF2CF30ABF2C898A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"429011\n");
+    end
+    ReadData1E = 64'hBFF110E2C0331245;
+    ReadData2E = 64'h47E0000010000FFF;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'hC7E110E2D1440615;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"429317\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"429623\n");
+    end
+    ReadData1E = 64'hC80FFFFFC0FFFFFE;
+    ReadData2E = 64'h9CE636531A22D396;
+    ReadData3E = 64'hCC000000403FFFFF;
+    ans = 64'hCC000000403FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"429929\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC3FFFFF80000007F;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"430235\n");
+    end
+    ReadData1E = 64'hB7E040000003FFFF;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'hC03FFFFFFFDFFBFF;
+    ans = 64'hC03FFFFFFFDFFBFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"430541\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h000E000000000040;
+    ReadData3E = 64'h3EF000000000010F;
+    ans = 64'h3EF000000000010F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"430847\n");
+    end
+    ReadData1E = 64'h802FFFFFFFF07FFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCA0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"431153\n");
+    end
+    ReadData1E = 64'h41C1008000000000;
+    ReadData2E = 64'h43EB1E5DE79D6E0D;
+    ReadData3E = 64'hBEB007FFFFFF8000;
+    ans = 64'h45BCD11CB90681D9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"431459\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'hB7E002FFFFFFFFFF;
+    ans = 64'hB7E002FFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"431765\n");
+    end
+    ReadData1E = 64'hC020000040000001;
+    ReadData2E = 64'hBFB000000000077F;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hBFF7FFFFDFFFFC3E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"432071\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"432377\n");
+    end
+    ReadData1E = 64'h40600000043FFFFE;
+    ReadData2E = 64'h4AB80191FEDD0220;
+    ReadData3E = 64'hC2520000000003FF;
+    ans = 64'h4B280192053D6CE5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"432683\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h40207FFFFFBFFFFF;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"432989\n");
+    end
+    ReadData1E = 64'h3FCB7B8B687AC30A;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'hCA50000000000408;
+    ans = 64'hCA50000000000408;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"433295\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FDFFFFFC1FFFFFF;
+    ReadData3E = 64'hC7FAFFFFFFFFFFFF;
+    ans = 64'hC7FAFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"433601\n");
+    end
+    ReadData1E = 64'h51900080000007FF;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h51900080000007FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"433907\n");
+    end
+    ReadData1E = 64'h80047FFFFFFFFFFF;
+    ReadData2E = 64'h3FF0000001008000;
+    ReadData3E = 64'h3FB5BEBC9BBB5778;
+    ans = 64'h3FB5BEBC9BBB5778;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"434213\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h1CA0000000000070;
+    ans = 64'h1CA0000000000070;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"434519\n");
+    end
+    ReadData1E = 64'h472578883E29B548;
+    ReadData2E = 64'h475A91AD5F59CD8E;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h4E91D3AD2F7635F8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"434825\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCA0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"435131\n");
+    end
+    ReadData1E = 64'h3BE7FFFFFFFFFFFD;
+    ReadData2E = 64'h480FFFFC003FFFFF;
+    ReadData3E = 64'hC7AFFFFF7FFFFFDE;
+    ans = 64'hC7AFFFFF7FFFFFDE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"435437\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hAA300001FFEFFFFE;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"435743\n");
+    end
+    ReadData1E = 64'h4FC000000001FFEF;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'h3F800011FFFFFFFF;
+    ans = 64'h4FC000000001FFEF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"436049\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBC5FBD681C0884C4;
+    ReadData3E = 64'h3D3FFC000000FFFF;
+    ans = 64'h3D3FFC000000FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"436355\n");
+    end
+    ReadData1E = 64'h000F0000001FFFFE;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h8000FFFFFFDFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"436661\n");
+    end
+    ReadData1E = 64'h339FFFFFFFF9FFFE;
+    ReadData2E = 64'h659F200000000000;
+    ReadData3E = 64'hC3E000003FFFDFFF;
+    ans = 64'h594F1FFFFFFA29FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"436967\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h13B7D8137EFDC31C;
+    ans = 64'h13B7D8137EFDC31C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"437273\n");
+    end
+    ReadData1E = 64'h7FF00000040001FF;
+    ReadData2E = 64'hBFFFFFFFFFFFEFFE;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'h7FF80000040001FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"437579\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h0037FFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"437885\n");
+    end
+    ReadData1E = 64'hC03FFFFFFFFBFFBF;
+    ReadData2E = 64'hBFFFE0003FFFFFFF;
+    ReadData3E = 64'h41E6E39FBC98F40E;
+    ans = 64'h41E6E39FC490F41E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"438191\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hB7F0000000100003;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"438497\n");
+    end
+    ReadData1E = 64'h40FB93DAC8FEC06B;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'h40100000007FFF00;
+    ans = 64'h410B93FAC8FEC16B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"438803\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3D9FFFFFFF800100;
+    ReadData3E = 64'hBCAFFFFFFFB7FFFE;
+    ans = 64'hBCAFFFFFFFB7FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"439109\n");
+    end
+    ReadData1E = 64'hBFDFC6D013CB57F9;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'hBFEFC6D013CB57FB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"439415\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFE3FFFFF;
+    ReadData2E = 64'h3FFFFFFFFFF7FFF7;
+    ReadData3E = 64'hED7EFFFF7FFFFFFE;
+    ans = 64'hED7EFFFF7FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"439721\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'hC0219DFC89EECA7C;
+    ans = 64'hC0219DFC89EECA7C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"440027\n");
+    end
+    ReadData1E = 64'hBD20000000200FFF;
+    ReadData2E = 64'hBFEB900DFBE9BCDF;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h3FE00000000000DC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"440333\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h003BFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"440639\n");
+    end
+    ReadData1E = 64'hDFD0000000010800;
+    ReadData2E = 64'h00020000000FFFFF;
+    ReadData3E = 64'hBFC0007FFFFFFFBE;
+    ans = 64'hBFC0007FFFFFFFBE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"440945\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h8010000000801FFF;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h400FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"441251\n");
+    end
+    ReadData1E = 64'h41CA78579544CC5A;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'h3187FFFFFFFEFFFF;
+    ans = 64'h41EA78579544CC58;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"441557\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h54AFFFFC40000000;
+    ReadData3E = 64'h76E00800000000FF;
+    ans = 64'h76E00800000000FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"441863\n");
+    end
+    ReadData1E = 64'hBF1BFFFFEFFFFFFF;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"442169\n");
+    end
+    ReadData1E = 64'h43CFFFFFF803FFFE;
+    ReadData2E = 64'h40D00004FFFFFFFF;
+    ReadData3E = 64'hCF20000000008800;
+    ans = 64'hCF20000000008800;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"442475\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'h3F00080400000000;
+    ans = 64'h3F00080400000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"442781\n");
+    end
+    ReadData1E = 64'h8020B3E20AEAF03E;
+    ReadData2E = 64'hC34F8007FFFFFFFF;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hBCAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"443087\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'h004FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"443393\n");
+    end
+    ReadData1E = 64'h3FDFFEFBFFFFFFFF;
+    ReadData2E = 64'hBFFFFFFFF7FFFF7F;
+    ReadData3E = 64'hC04ADED407B3CC8E;
+    ans = 64'hC04B5ECFF793CD90;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"443699\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FD0000010000007;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hC000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"444005\n");
+    end
+    ReadData1E = 64'hB81FFFC000000020;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'h0019444730A7E4F3;
+    ans = 64'hB84FFFC00000001E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"444311\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FD0000041FFFFFF;
+    ReadData3E = 64'h400100007FFFFFFF;
+    ans = 64'h400100007FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"444617\n");
+    end
+    ReadData1E = 64'h47E0800001FFFFFE;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"444923\n");
+    end
+    ReadData1E = 64'h3CA0007FFDFFFFFE;
+    ReadData2E = 64'h4D40000081FFFFFF;
+    ReadData3E = 64'h400806D221155416;
+    ans = 64'h49F0008080040FED;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"445229\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'h40FFEBFFFFFFFFFE;
+    ans = 64'h40FFEBFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"445535\n");
+    end
+    ReadData1E = 64'h38100000100FFFFE;
+    ReadData2E = 64'h402FFFF0000003FE;
+    ReadData3E = 64'h3CA0000000000000;
     ans = 64'h3CA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"445841\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"446147\n");
+    end
+    ReadData1E = 64'h3FF1FFFFFEFFFFFE;
+    ReadData2E = 64'h4159EFFAF3E842A2;
+    ReadData3E = 64'hBFD0000100003FFE;
+    ans = 64'h415D2DFA40C64A44;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"446453\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h401FFFFFBFFFFEFE;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h3FF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"446759\n");
+    end
+    ReadData1E = 64'h403F000000040000;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h400F9880943E2802;
+    ans = 64'h439F00000003FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"447065\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBF7F360561360260;
+    ReadData3E = 64'h44C9E2E2A78E50F2;
+    ans = 64'h44C9E2E2A78E50F2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"447371\n");
+    end
+    ReadData1E = 64'hC0500001F8000000;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'hC3AF8003EFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"447677\n");
+    end
+    ReadData1E = 64'h3E11000000000020;
+    ReadData2E = 64'h3FD00007FFFFFFFD;
+    ReadData3E = 64'hC8654A4F1E1F4FDC;
+    ans = 64'hC8654A4F1E1F4FDC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"447983\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'h3810000010020000;
+    ans = 64'h400FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"448289\n");
+    end
+    ReadData1E = 64'h43D0000000080007;
+    ReadData2E = 64'h2ACFFFEFFFBFFFFF;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h2EAFFFEFFFD00005;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"448595\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"448901\n");
+    end
+    ReadData1E = 64'h002FFFFFFF000000;
+    ReadData2E = 64'h54EFFFFFFE3FFFFF;
+    ReadData3E = 64'hFFC003FFFFFFFFFF;
+    ans = 64'hFFC003FFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"449207\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC1FFFFFFF800001F;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hBFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"449513\n");
+    end
+    ReadData1E = 64'h3EF0000407FFFFFE;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFBB0E2E40869182;
+    ans = 64'h7EF0000407FFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"449819\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FB2E318F3B70CE6;
+    ReadData3E = 64'hFF432ECC5E786035;
+    ans = 64'hFF432ECC5E786035;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"450125\n");
+    end
+    ReadData1E = 64'h3FFFFFFF81FFFFFF;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"450431\n");
+    end
+    ReadData1E = 64'hC05FFFFFFFFFFF7E;
+    ReadData2E = 64'hC80FFFBFFFFFFF7E;
+    ReadData3E = 64'h480C1D6E12BFFBDE;
+    ans = 64'h48801BFD6E12BF7A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"450737\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h4B9000000007DFFF;
+    ans = 64'h4B9000000007DFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"451043\n");
+    end
+    ReadData1E = 64'h47F0FBFFFFFFFFFF;
+    ReadData2E = 64'h48007FFFFFFFFDFF;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h500183DFFFFFFDDE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"451349\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"451655\n");
+    end
+    ReadData1E = 64'hC0674B0ABB8C523C;
+    ReadData2E = 64'h43E003FFF8000000;
+    ReadData3E = 64'h9D500000010FFFFF;
+    ans = 64'hC45750DD7295AFF3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"451961\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FD4BFB4A018A1E6;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h4008BFB4A018A1E5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"452267\n");
+    end
+    ReadData1E = 64'hBFD6729F998C9D9E;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'hC730000001FFF7FF;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"452573\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFDFFFFFFF3FFFFE;
+    ReadData3E = 64'h381FFFFFFBFFFFFE;
+    ans = 64'h381FFFFFFBFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"452879\n");
+    end
+    ReadData1E = 64'h427000001FFFFC00;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"453185\n");
+    end
+    ReadData1E = 64'hC800001000000003;
+    ReadData2E = 64'h3F1039D67DF32534;
+    ReadData3E = 64'hBF700000000007FF;
+    ans = 64'hC72039E6B7C9A32A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"453491\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h456A3212BAB43622;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"453797\n");
+    end
+    ReadData1E = 64'h403001000000001F;
+    ReadData2E = 64'h40220FFFFFFFFFFF;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"454103\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"454409\n");
+    end
+    ReadData1E = 64'hBF7FE8F6D20EF31D;
+    ReadData2E = 64'h401E00000000003E;
+    ReadData3E = 64'h3FEFFFFFFFF01FFF;
+    ans = 64'h3FEE215989A13FBC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"454715\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hB7FFFFFFFFF7FFDF;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'hBFD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"455021\n");
+    end
+    ReadData1E = 64'h002FFFFFFFFFFFFE;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'h7FDFC000003FFFFF;
+    ans = 64'h7FDFC000003FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"455327\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h2243DFFFFFFFFFFE;
+    ReadData3E = 64'hF575672B472E7543;
+    ans = 64'hF575672B472E7543;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"455633\n");
+    end
+    ReadData1E = 64'hC34FFF7FFFFFBFFF;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hC00FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"455939\n");
+    end
+    ReadData1E = 64'h5BE07FFFFFFFFFFF;
+    ReadData2E = 64'hC1C8DB69C5C29889;
+    ReadData3E = 64'h3F1FFFFFFFC01000;
+    ans = 64'hDDB9A24513F0AD4C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"456245\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'hC1F90BEF36AF6276;
+    ans = 64'hC1F90BEF36AF6276;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"456551\n");
+    end
+    ReadData1E = 64'hC32D08A5B4CB2446;
+    ReadData2E = 64'hC300000001007FFF;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"456857\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h4010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"457163\n");
+    end
+    ReadData1E = 64'h380FFDFFFFFFFFFD;
+    ReadData2E = 64'hC7E0000000040200;
+    ReadData3E = 64'hFFD1FFFFFFFFFFFE;
+    ans = 64'hFFD1FFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"457469\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3F8FFFC000000001;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'h3CA0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"457775\n");
+    end
+    ReadData1E = 64'hBCA2F22027F558C5;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'hC86FFF2000000000;
+    ans = 64'hC86FFF2000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"458081\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hCD2000000FFFFEFF;
+    ReadData3E = 64'h41CB8762E572139A;
+    ans = 64'h41CB8762E572139A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"458387\n");
+    end
+    ReadData1E = 64'hBFD20FFFFFFFFFFF;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"458693\n");
+    end
+    ReadData1E = 64'hB803BB596AD832F9;
+    ReadData2E = 64'h41E02D7CF46C5A88;
+    ReadData3E = 64'hB1F00000007FBFFE;
+    ans = 64'hB9F3F3726FB862F2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"458999\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFE68188CE9F46C1;
+    ans = 64'hBFE68188CE9F46C1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"459305\n");
+    end
+    ReadData1E = 64'hBE407FFFFFFFFFFE;
+    ReadData2E = 64'h3FD84D410DEC4BE3;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"459611\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hC00FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"459917\n");
+    end
+    ReadData1E = 64'hC3E0000000000440;
+    ReadData2E = 64'h3C2FFF000000007F;
+    ReadData3E = 64'hA3E000001FFE0000;
+    ans = 64'hC01FFF00000008FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"460223\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hB820000040020000;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h801FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"460529\n");
+    end
+    ReadData1E = 64'hC800000FFFF7FFFE;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'hC3C0100010000000;
+    ans = 64'hC3C0100010000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"460835\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h0011FFFFFF7FFFFE;
+    ReadData3E = 64'hC1DFFFFEFFF7FFFF;
+    ans = 64'hC1DFFFFEFFF7FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"461141\n");
+    end
+    ReadData1E = 64'h2CB0800000000800;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"461447\n");
+    end
+    ReadData1E = 64'h37EF00000000007F;
+    ReadData2E = 64'h9DE0000000000FFC;
+    ReadData3E = 64'hBF0FFFFFFFFFFDF6;
+    ans = 64'hBF0FFFFFFFFFFDF6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"461753\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'h409FFFFFEFFFFFBF;
+    ans = 64'h409FFFFFEFFFFFBF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"462059\n");
+    end
+    ReadData1E = 64'h8027B36FC882BDE2;
+    ReadData2E = 64'h002FFFFFFFFFFC03;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"462365\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"462671\n");
+    end
+    ReadData1E = 64'h403FFFFFFF00001F;
+    ReadData2E = 64'h380FFFFFFF000800;
+    ReadData3E = 64'h40300000000F7FFF;
+    ans = 64'h40300000000F7FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"462977\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC39FFFFFFC000008;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'h83CFFFFFFC000007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"463283\n");
+    end
+    ReadData1E = 64'h80120DDC76612AE5;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'h46AAF8F1DA03076B;
+    ans = 64'h46AAF8F1DA03076B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"463589\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC03770390354A8D4;
+    ReadData3E = 64'h3E9000FFFFFFF000;
+    ans = 64'h3E9000FFFFFFF000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"463895\n");
+    end
+    ReadData1E = 64'hA4A1D2744FEB9D7F;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h3FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"464201\n");
+    end
+    ReadData1E = 64'h4031B1054AFF739B;
+    ReadData2E = 64'hFFD0000080000004;
+    ReadData3E = 64'hBFE000010FFFFFFE;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"464507\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'h4830000FFFC00000;
+    ans = 64'h4830000FFFC00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"464813\n");
+    end
+    ReadData1E = 64'hFFD0000000000FFF;
+    ReadData2E = 64'h4800400040000000;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"465119\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"465425\n");
+    end
+    ReadData1E = 64'hC02FFFFFC00003FF;
+    ReadData2E = 64'hC34FFFF8000003FE;
+    ReadData3E = 64'h845FFFF7FFFBFFFE;
+    ans = 64'h438FFFF7C00017FD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"465731\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3E50000000003FEF;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h0000000008000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"466037\n");
+    end
+    ReadData1E = 64'h407FFFF0000001FF;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'h306B9067D3C8EFCE;
+    ans = 64'hC06FFFF0000001FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"466343\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC570400000000FFE;
+    ReadData3E = 64'h47EFBFFBFFFFFFFF;
+    ans = 64'h47EFBFFBFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"466649\n");
+    end
+    ReadData1E = 64'h3F4F80001FFFFFFE;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFE003F00003FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"466955\n");
+    end
+    ReadData1E = 64'h1FE000000020001F;
+    ReadData2E = 64'h8027BF4A25DCD90E;
+    ReadData3E = 64'hBD9199B5B792B56D;
+    ans = 64'hBD9199B5B792B56D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"467261\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'hBFD000001000001F;
+    ans = 64'hBFD000001000001F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"467567\n");
+    end
+    ReadData1E = 64'h37E0400000000FFF;
+    ReadData2E = 64'hBF6FFFFFFFDF7FFE;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"467873\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h3FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"468179\n");
+    end
+    ReadData1E = 64'h3EF0000080000100;
+    ReadData2E = 64'h3D76E46D9FFCED73;
+    ReadData3E = 64'hA8965757C3E2E3B5;
+    ans = 64'h3C76E46E57205BE1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"468485\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h400FFFFC0000001E;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"468791\n");
+    end
+    ReadData1E = 64'hBFDFC00400000000;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hC1F31AF02D2008C2;
+    ans = 64'hC1F31AF02D1818C1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"469097\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h8B90000040000001;
+    ReadData3E = 64'hC34FBA3A82A10FA5;
+    ans = 64'hC34FBA3A82A10FA5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"469403\n");
+    end
+    ReadData1E = 64'hC1E0006FFFFFFFFF;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h41E0006FFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
@@ -35994,7189 +59893,11971 @@ initial
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
     	$fwrite(fp,"469709\n");
     end
-    x = 64'h432FFFFFFFFFFF03;
-    y = 64'h4800000004000040;
-    z = 64'hC340000000000001;
-    ans = 64'h4B40000003FFFFC1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h7AC002003FFFFFFF;
+    ReadData2E = 64'h40D000000003FFF0;
+    ReadData3E = 64'hC04FFC000003FFFE;
+    ans = 64'h7BA002004004006F;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"470323\n");
+    	$fwrite(fp,"470015\n");
     end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hBFF0000000000001;
-    z = 64'hC3FED13CC475191F;
-    ans = 64'hC3FED13CC475191F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h404FFFFFFFFE0080;
+    ans = 64'h404FFFFFFFFE0080;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"470937\n");
+    	$fwrite(fp,"470321\n");
     end
-    x = 64'h3FEFFFFFFFDF7FFE;
-    y = 64'hFFF50D33EA30BABA;
-    z = 64'hB7EFFFFFFFFFFFE7;
-    ans = 64'hFFFD0D33EA30BABA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"471551\n");
-    end
-    x = 64'h000FE0000001FFFE;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"472165\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hBFFFFBEFFFFFFFFF;
-    z = 64'hC1FFFFFFFFFFF80F;
-    ans = 64'hC1FFFFFFFFFFF80F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"472779\n");
-    end
-    x = 64'h42507FFFFFFFFEFF;
-    y = 64'hC000000000000000;
-    z = 64'h3FA1F463B7BB4598;
-    ans = 64'hC2607FFFFFFFFDE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"473393\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h47FFFFFE03FFFFFF;
-    z = 64'h8000000000000001;
-    ans = 64'h082FFFFE03FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"474007\n");
-    end
-    x = 64'h401F000000000007;
-    y = 64'hFFFFFEFDFFFFFFFF;
-    z = 64'h768FFFFFBFFFFF80;
-    ans = 64'hFFFFFEFDFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"474621\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h0010000000000001;
-    ans = 64'h803BFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"475235\n");
-    end
-    x = 64'h43E872992068804E;
-    y = 64'h1ABFFDFFFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"475849\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hC010000000000000;
-    z = 64'h43C0010080000000;
-    ans = 64'h43C0010080000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"476463\n");
-    end
-    x = 64'h4190000000000010;
-    y = 64'h3FF6881A2C6EC3DE;
-    z = 64'h7FEFFFBFFEFFFFFF;
-    ans = 64'h7FEFFFBFFEFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"477077\n");
-    end
-    x = 64'hB7F58D085BCBA2EF;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"477691\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hC03FFFFBFFFF7FFE;
-    z = 64'h7FE000FFFFFFFBFF;
-    ans = 64'h7FE000FFFFFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"478305\n");
-    end
-    x = 64'h403EFFFFFFFBFFFF;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hC42DDFFFFFFFFFFF;
-    ans = 64'hC42DDFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"478919\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h3FCFFF0000001000;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"479533\n");
-    end
-    x = 64'h380FFFFFFFFFF803;
-    y = 64'h4038000007FFFFFF;
-    z = 64'hBFB00000000002FF;
-    ans = 64'hBFB00000000002FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"480147\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h837FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"480761\n");
-    end
-    x = 64'h8FCFC0000000000F;
-    y = 64'hC396E75DCC0BEDB1;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"481375\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h380E84D8FBC60A34;
-    ans = 64'h380E84D8FBC60A34;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"481989\n");
-    end
-    x = 64'h402F800008000000;
-    y = 64'hC9200003FFFDFFFE;
-    z = 64'hC3E3B93E1C073F21;
-    ans = 64'hC95F8007E7FC11FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"482603\n");
-    end
-    x = 64'h39B00000FFFFFF7E;
-    y = 64'hFFE0000000000001;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'hF9A00000FFFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"483217\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'h3814040000000000;
-    z = 64'hBFFB9BC145D76013;
-    ans = 64'hBFFB9BC145D76013;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"483831\n");
-    end
-    x = 64'hB81FFFFBFFFFFFEE;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hC8BBFDFFFFFFFFFE;
-    ans = 64'h781FFFFBFFFFFFED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"484445\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hC7F0002000000040;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"485059\n");
-    end
-    x = 64'hBE70000000400010;
-    y = 64'h41298E77258CB436;
-    z = 64'hBE801FFFFFFFFFE0;
-    ans = 64'hBFA98E7B2DF2EE2C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"485673\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hFFF0000000000000;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"486287\n");
-    end
-    x = 64'h4FB01FFFFFFF0000;
-    y = 64'h3FF9AB4DFB9A7412;
-    z = 64'hC000000000000000;
-    ans = 64'h4FB9DEA497900E45;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"486901\n");
-    end
-    x = 64'h001FFFFFFFFFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hC04FFFFFFFFC0003;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"487515\n");
-    end
-    x = 64'h43FFF2FFF2870904;
-    y = 64'h8B97AB5EF0099570;
-    z = 64'hBA5FEFFBFFFFFFFE;
-    ans = 64'hBA5FEFFBFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"488129\n");
-    end
-    x = 64'h41E020000007FFFF;
-    y = 64'h0000000000000000;
-    z = 64'h3CA0000000000000;
-    ans = 64'h3CA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"488743\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hC3D6A3A9253C9470;
-    z = 64'h3FB000000000013F;
-    ans = 64'h3FB000000000013F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"489357\n");
-    end
-    x = 64'hDC10000000001EFF;
-    y = 64'h0000000000000001;
-    z = 64'h802D63F274ADA691;
-    ans = 64'h98F0000000001EFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"489971\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBFC007FFFFFFFFFB;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"490585\n");
-    end
-    x = 64'hBFD200007FFFFFFF;
-    y = 64'hC34B916DE7248984;
-    z = 64'hC1CF67F6D68E7232;
-    ans = 64'h432F039C02F4AE92;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"491199\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"491813\n");
-    end
-    x = 64'h408FFFFFFFF003FF;
-    y = 64'hBFF01DFFFFFFFFFF;
-    z = 64'hBFF0000000000001;
-    ans = 64'hC09021FFFFF7F302;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"492427\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h0010000000000001;
-    z = 64'h800E000000002000;
-    ans = 64'h800E000000002000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"493041\n");
-    end
-    x = 64'hC1CFFFFFEFFDFFFF;
-    y = 64'h402DFFFFFFFFFF80;
-    z = 64'hC1D00400003FFFFF;
-    ans = 64'hC210003FF8830FBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"493655\n");
-    end
-    x = 64'h3FD3D4BA52CE9C8D;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h0010000000000001;
-    ans = 64'h0019EA5D29674E47;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"494269\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h801FFFFFFFFFFC7E;
-    z = 64'hC00FFFFFFFFFFDDF;
-    ans = 64'hC00FFFFFFFFFFDDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"494883\n");
-    end
-    x = 64'h0C8FFFFC000000FF;
-    y = 64'h3CA0000000000000;
-    z = 64'hC051E56F7DD285F6;
-    ans = 64'hC051E56F7DD285F6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"495497\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBFEFFFFE07FFFFFE;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"496111\n");
-    end
-    x = 64'hC02FFFFFFFC01FFF;
-    y = 64'hC7CF107CC9D31F6F;
-    z = 64'h801E5BA459AF6A18;
-    ans = 64'h480F107CC9951D85;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"496725\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"497339\n");
-    end
-    x = 64'h7FEDD366C08DD3A9;
-    y = 64'hC28FFFDEFFFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"497953\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h3FD0000000000000;
-    z = 64'hBFEFF5FFFFFFFFFF;
-    ans = 64'hBFEFF5FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"498567\n");
-    end
-    x = 64'h3FF0000000200FFF;
-    y = 64'hC7E0FFFFFFFF0000;
-    z = 64'hC352890E4983B6C0;
-    ans = 64'hC7E10000002110FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"499181\n");
-    end
-    x = 64'hB815E5AD5F1699AF;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hB805E5AD5F1699AE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"499795\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBFC010000000000F;
-    z = 64'h3FE0000017FFFFFF;
-    ans = 64'h3FE0000017FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"500409\n");
-    end
-    x = 64'hC3F000000000BFFE;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h3F4FFFFFFFFFFF3E;
-    ans = 64'hC3E000000000BFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"501023\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hC03FC01000000000;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"501637\n");
-    end
-    x = 64'h801000009FFFFFFE;
-    y = 64'h452CFCD0228D0030;
-    z = 64'h7FD000FFFFFF8000;
-    ans = 64'h7FD000FFFFFF8000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"502251\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h3FE0000000000001;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"502865\n");
-    end
-    x = 64'hBF844323FF911B3D;
-    y = 64'h8E2FFFFFF0000002;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"503479\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hFFE00020000003FF;
-    ans = 64'hFFE00020000003FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"504093\n");
-    end
-    x = 64'hC66000FFFBFFFFFE;
-    y = 64'h44F0003FEFFFFFFF;
-    z = 64'h41DFFFFFFC0007FE;
-    ans = 64'hCB60013FEFFEF001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"504707\n");
-    end
-    x = 64'h3847AC8111864E13;
-    y = 64'h3FF0000000000000;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"505321\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h47EFFFFFFF400000;
-    z = 64'h39D801FFFFFFFFFE;
-    ans = 64'h39D801FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"505935\n");
-    end
-    x = 64'hA4C0020003FFFFFF;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hC3DFFEFFFFFDFFFF;
-    ans = 64'hC3DFFEFFFFFDFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"506549\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hFFF000100000003F;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'hFFF800100000003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"507163\n");
-    end
-    x = 64'h40300000101FFFFF;
-    y = 64'h403CC2DCC09CCB9F;
-    z = 64'hBFFFFFFFF8000100;
-    ans = 64'h407CA2DCDDA12E16;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"507777\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h4000000000000000;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"508391\n");
-    end
-    x = 64'h3FF0000000000806;
-    y = 64'hBFE00000000000FF;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFE8000000000905;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"509005\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h3FEBFFFFC0000000;
-    ans = 64'h3FEBFFFFC0000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"509619\n");
-    end
-    x = 64'h8E70000000080004;
-    y = 64'hBF4FFFFFFFC0001E;
-    z = 64'hC03FFFF000000001;
-    ans = 64'hC03FFFF000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"510233\n");
-    end
-    x = 64'hFFF7211EB044CF02;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFFF211EB044CF02;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"510847\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBFCBFF7FFFFFFFFF;
-    z = 64'h43C0040000007FFE;
-    ans = 64'h43C0040000007FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"511461\n");
-    end
-    x = 64'hC123FFFFFBFFFFFF;
-    y = 64'h4010000000000001;
-    z = 64'hC8000001FFFFFFEF;
-    ans = 64'hC8000001FFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"512075\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h41CFFFFE00001FFE;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"512689\n");
-    end
-    x = 64'h2AECFBC4733AA5DB;
-    y = 64'hC02FFDFFFFF7FFFF;
-    z = 64'hDD107FFFFFF7FFFF;
-    ans = 64'hDD107FFFFFF7FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"513303\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hC010000000000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"513917\n");
-    end
-    x = 64'hBFE007FFFFFFFFEF;
-    y = 64'h80200000000000FF;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"514531\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h4340000000000001;
-    z = 64'h43DFFFE00007FFFF;
-    ans = 64'h43DFFFE00007FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"515145\n");
-    end
-    x = 64'hBCAFFFFFFFFC0FFE;
-    y = 64'h37E0FFFFFFC00000;
-    z = 64'hBFB3A6E10298147B;
-    ans = 64'hBFB3A6E10298147B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"515759\n");
-    end
-    x = 64'hBFD00000000200FE;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"516373\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h3FE02FFFFFFFFFFE;
-    z = 64'h328FBFFFFFFFFEFE;
-    ans = 64'h328FBFFFFFFFFEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"516987\n");
-    end
-    x = 64'hC2BFF00000000006;
-    y = 64'h7FE0000000000000;
-    z = 64'h3F6FFC00000FFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"517601\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBFB0000000000000;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"518215\n");
-    end
-    x = 64'hC03FFFFFFFFFC00E;
-    y = 64'hC1C000007C000000;
-    z = 64'h434FFFFDFFFDFFFF;
-    ans = 64'h434FFFFFFFFE0F7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"518829\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hC000000000000001;
-    ans = 64'h4017FFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"519443\n");
-    end
-    x = 64'h801FFBFFFFDFFFFE;
-    y = 64'h002C7FFFFFFFFFFE;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h801FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"520057\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h7FF0000000000000;
-    z = 64'hC4A7AD9414DA3394;
+    ReadData1E = 64'h7FDE1D66FE274D5D;
+    ReadData2E = 64'h401FFF00000000FE;
+    ReadData3E = 64'h4000000000000001;
     ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"520671\n");
+    	$fwrite(fp,"470627\n");
     end
-    x = 64'hC07815AA5F6B0FEC;
-    y = 64'hC8F0000007FBFFFE;
-    z = 64'h381FFFC0000FFFFE;
-    ans = 64'h497815AA6B6FDFAE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"521285\n");
+    	$fwrite(fp,"470933\n");
     end
-    x = 64'h41E833C7BBCD2C9D;
-    y = 64'h7FF0000000000001;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0040080000000;
+    ReadData2E = 64'h3FBFFFFFEFFFFBFF;
+    ReadData3E = 64'h357FFFFFFFFF8001;
+    ans = 64'h3FA0040077FDFDBF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"521899\n");
+    	$fwrite(fp,"471239\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h3FE8001FFFFFFFFE;
-    z = 64'h3EEF8000001FFFFF;
-    ans = 64'h3EEF8000001FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"522513\n");
-    end
-    x = 64'h40CFFFEFFFFFFC00;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'hC7EFFFFFF5FFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"523127\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hC3FFFFFC001FFFFF;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"523741\n");
-    end
-    x = 64'hC0BFFFFFFDFFC000;
-    y = 64'h37E00080000003FF;
-    z = 64'h480D3EE09C1ED5B4;
-    ans = 64'h480D3EE09C1ED5B4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"524355\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h8000000000000001;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"524969\n");
-    end
-    x = 64'h380FFFFFBFFFFFF7;
-    y = 64'h41D000000FBFFFFF;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h39EFFFFFDF7FFFB6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"525583\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h4007A97DE77E4C18;
-    ans = 64'h4007A97DE77E4C18;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"526197\n");
-    end
-    x = 64'hC3F3FFFF7FFFFFFE;
-    y = 64'h47EFFFFF000001FF;
-    z = 64'hC0301FFFFC000000;
-    ans = 64'hCBF3FFFEE000053D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"526811\n");
-    end
-    x = 64'h41CFB516C073EDBC;
-    y = 64'h8010000000000000;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"527425\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h2E8FFFFEC0000000;
-    z = 64'h40E090744244D531;
-    ans = 64'h40E090744244D531;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"528039\n");
-    end
-    x = 64'h46910000003FFFFF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hC008371E39861C0C;
-    ans = 64'hC008371E39861C0C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"528653\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h002F50F3A5D280F0;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"529267\n");
-    end
-    x = 64'h41F0000000001000;
-    y = 64'hBE00000001F7FFFF;
-    z = 64'hC00DD214F016BF5E;
-    ans = 64'hC016E90A790767AF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"529881\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBCA0000000000000;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"530495\n");
-    end
-    x = 64'hBFDA764348037620;
-    y = 64'h380E00000000000F;
-    z = 64'h8000000000000000;
-    ans = 64'hB7F8CEDF13833ECA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"531109\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h4FC000000080003F;
-    ans = 64'h4FC000000080003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"531723\n");
-    end
-    x = 64'hBFDF80000007FFFE;
-    y = 64'hA1F0000004003FFE;
-    z = 64'h40200000000003FC;
-    ans = 64'h40200000000003FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"532337\n");
-    end
-    x = 64'h2860008007FFFFFE;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hC010000000000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"532951\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h403123775A6D2DD2;
-    z = 64'h3CA0000000000401;
-    ans = 64'h3CA0000000000401;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"533565\n");
-    end
-    x = 64'h8AD00003FFF7FFFF;
-    y = 64'hBFD0000000000001;
-    z = 64'h48C7FFFFFFFFFEFF;
-    ans = 64'h48C7FFFFFFFFFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"534179\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hC19001FFFF7FFFFE;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"534793\n");
-    end
-    x = 64'hBDEF6966E82E31CA;
-    y = 64'hFFD169C9EC6EC12F;
-    z = 64'h3FBFFFFFFFFFFAFE;
-    ans = 64'h7DD117D6BB26D34D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"535407\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"536021\n");
-    end
-    x = 64'hB7FE475C439E7B31;
-    y = 64'h40AFFFE000000003;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"536635\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBFE0000000000001;
-    z = 64'hC0B00000007FEFFF;
-    ans = 64'hC0B00000007FEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"537249\n");
-    end
-    x = 64'hC1DFFFFFF0000008;
-    y = 64'hBFCFFFDFFFFFFFF7;
-    z = 64'h3F9FEFFFFFFFFFFF;
-    ans = 64'h41BFFFDFF0080BFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"537863\n");
-    end
-    x = 64'h3FC03FFFFEFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hC000000000000001;
-    ans = 64'hC00103FFFFF00001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"538477\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hC3EFBFFFFFFFDFFE;
-    z = 64'h413003FFEFFFFFFF;
-    ans = 64'h413003FFEFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"539091\n");
-    end
-    x = 64'hBCAFFFFFFF7FFF7F;
-    y = 64'hBFF0000000000000;
-    z = 64'hC01FFFFF80000400;
-    ans = 64'hC01FFFFF80000400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"539705\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBD0FFFEFFFFFC000;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3CA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"540319\n");
-    end
-    x = 64'hBFB0807FFFFFFFFF;
-    y = 64'h1FE000000003FC00;
-    z = 64'h3FBCE60789BFE91F;
-    ans = 64'h3FBCE60789BFE91F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"540933\n");
-    end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"541547\n");
-    end
-    x = 64'h40D000201FFFFFFF;
-    y = 64'hC050000800010000;
-    z = 64'h7FEFFFFFFFFFFFFF;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h002FFF80000003FE;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
     ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"542161\n");
+    	$fwrite(fp,"471545\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hC000000000000000;
-    z = 64'hC027B5C169FB9BF9;
-    ans = 64'hC027B5C169FB9BF9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC18000FFBFFFFFFF;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'h0EF6C97A58CFBD2E;
+    ans = 64'h418000FFC0000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"542775\n");
+    	$fwrite(fp,"471851\n");
     end
-    x = 64'h3FF000001FFFFFFB;
-    y = 64'h7FFFFFFFFBFFFDFF;
-    z = 64'h7FF00001FBFFFFFF;
-    ans = 64'h7FFFFFFFFBFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC7AAF283BA042806;
+    ReadData3E = 64'h3FBA9508F09BCF9D;
+    ans = 64'h3FBA9508F09BCF9D;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"543389\n");
+    	$fwrite(fp,"472157\n");
     end
-    x = 64'h4020001FFFFFFFBF;
-    y = 64'hC000000000000001;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hC032001FFFFFFFC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h450F37C9621767D3;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hC51F37C9621767D2;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"544003\n");
+    	$fwrite(fp,"472463\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hC01FFFFFFE000001;
-    z = 64'hB806F34352FD18A5;
-    ans = 64'hB806F34352FD18A5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFF007B2DC33D3AC;
+    ReadData2E = 64'hBFE02000003FFFFE;
+    ReadData3E = 64'h47E0000400010000;
+    ans = 64'h47E0000400010000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"544617\n");
+    	$fwrite(fp,"472769\n");
     end
-    x = 64'hC02000003FFFBFFF;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hBFE00001000003FE;
-    ans = 64'h403F800077FF7FDC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h3CABEF444A1B7558;
+    ans = 64'h3CABEF444A1B7558;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"545231\n");
+    	$fwrite(fp,"473075\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h357FFFFFEFFFFFFC;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h001FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFE0000007FFFFFF;
+    ReadData2E = 64'hC3E000801FFFFFFF;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"545845\n");
+    	$fwrite(fp,"473381\n");
     end
-    x = 64'hFFDEFFFFFFFFEFFE;
-    y = 64'h37FFFFF7FFFFFF80;
-    z = 64'h41DFFFFBFFFE0000;
-    ans = 64'hF7EEFFF83FFFEF82;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h3CAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"546459\n");
+    	$fwrite(fp,"473687\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hC010000000000001;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC3C001FE00000000;
+    ReadData2E = 64'h41C822E65EA006B2;
+    ReadData3E = 64'h5B90000000080100;
+    ans = 64'h5B90000000080100;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"547073\n");
+    	$fwrite(fp,"473993\n");
     end
-    x = 64'h41FDFFABFA74E0B2;
-    y = 64'hBFDC6DD0BA79DD66;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFF95655BD7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFF200;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"547687\n");
+    	$fwrite(fp,"474299\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hB81FFFFFFFF77FFE;
-    ans = 64'hB81FFFFFFFF77FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FBF8000001FFFFE;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'h37E00000007FEFFE;
+    ans = 64'hBFCF800000200000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"548301\n");
+    	$fwrite(fp,"474605\n");
     end
-    x = 64'h3FB0107FFFFFFFFF;
-    y = 64'h80100FFFFFFFFFDE;
-    z = 64'hC3E0100010000000;
-    ans = 64'hC3E0100010000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC08FFFFFE01FFFFF;
+    ReadData3E = 64'hC02FFFFFFFFBFF7E;
+    ans = 64'hC02FFFFFFFFBFF7E;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"548915\n");
+    	$fwrite(fp,"474911\n");
     end
-    x = 64'hC3FFFFE00000003E;
-    y = 64'hC340000000000000;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h474FFFE00000003E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FC004FFFFFFFFFE;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'hBFE004FFFFFFFFFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"549529\n");
+    	$fwrite(fp,"475217\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h3FFFFFEFF0000000;
-    z = 64'hFFEF80FFFFFFFFFF;
-    ans = 64'hFFEF80FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3E035583CD466A30;
+    ReadData2E = 64'h002000000000BFFE;
+    ReadData3E = 64'hCC41000001FFFFFE;
+    ans = 64'hCC41000001FFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"550143\n");
+    	$fwrite(fp,"475523\n");
     end
-    x = 64'h43C0660CA00BB7AA;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h3ED00000FF7FFFFF;
-    ans = 64'hC720660CA00BB7A9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h4010000000000820;
+    ans = 64'h4010000000000820;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"550757\n");
+    	$fwrite(fp,"475829\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'h3FDDFBFFFFFFFFFF;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h001EFDFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h40500000000006FE;
+    ReadData2E = 64'hBF3078FF64F622E6;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'h3FEF7C3804D84EAD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"551371\n");
+    	$fwrite(fp,"476135\n");
     end
-    x = 64'hBA57FFFFFFFFFBFF;
-    y = 64'h3FCED58246AC34ED;
-    z = 64'h380B7EF6003637E4;
-    ans = 64'hBA372021B4FDB3F7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hBCA0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"551985\n");
+    	$fwrite(fp,"476441\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hFFE0000000000000;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hCC7FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFE3FFFFFFEFFFFF;
+    ReadData3E = 64'h49DFFF7DFFFFFFFE;
+    ans = 64'h4C73FFFFFFF007FE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"552599\n");
+    	$fwrite(fp,"476747\n");
     end
-    x = 64'h43C00000000FBFFF;
-    y = 64'h8000043FFFFFFFFF;
-    z = 64'h4340000000000000;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBFF94B59D0203802;
+    ReadData3E = 64'h4340000000000000;
     ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"553213\n");
+    	$fwrite(fp,"477053\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hC1C3414AF94B6C96;
-    ans = 64'hC1C3414AFD4B6C96;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h801FFFF0000FFFFF;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'h3F04D4E9A95B7E9A;
+    ans = 64'h3F04D4E9A95B7E9A;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"553827\n");
+    	$fwrite(fp,"477359\n");
     end
-    x = 64'h3E0FFFFFF800000E;
-    y = 64'hC00FFFFF7FFFFFFF;
-    z = 64'h37EFFFFFFFF83FFF;
-    ans = 64'hBE2FFFFF7800002D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hAB8FFFC00000001E;
+    ReadData3E = 64'h43E07FFBFFFFFFFF;
+    ans = 64'h43E07FFBFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"554441\n");
+    	$fwrite(fp,"477665\n");
     end
-    x = 64'h0020000000000240;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hBFE0000000000000;
-    ans = 64'hC02100000000023F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h37EFFDFFFFFFFBFE;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'hB80FFDFFFFFFFC00;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"555055\n");
+    	$fwrite(fp,"477971\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBFF00800000FFFFE;
-    z = 64'hBFBFFFFF7FFDFFFF;
-    ans = 64'hBFBFFFFF7FFDFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC34020000000001F;
+    ReadData2E = 64'hC34FFFFFFFFFFFF0;
+    ReadData3E = 64'h7FE277DFE7545D62;
+    ans = 64'h7FE277DFE7545D62;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"555669\n");
+    	$fwrite(fp,"478277\n");
     end
-    x = 64'hBFEFFEFFFFFF0000;
-    y = 64'hFFF0000000000001;
-    z = 64'hBFD0010001FFFFFF;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'hC034585A9C396FF4;
+    ans = 64'hC034585A9C396FF4;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"556283\n");
+    	$fwrite(fp,"478583\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hBFE942E0EAAF09E3;
-    z = 64'h0000000000000000;
-    ans = 64'h801942E0EAAF09E1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0001FDFFFFFFE;
+    ReadData2E = 64'hB59FFFFFFFFDFFFA;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hBFE0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"556897\n");
+    	$fwrite(fp,"478889\n");
     end
-    x = 64'h43420003FFFFFFFF;
-    y = 64'hC06000FFFFFFFFF7;
-    z = 64'hFFF0000201FFFFFF;
-    ans = 64'hFFF8000201FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h804DFFFFFFFFFFFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"557511\n");
+    	$fwrite(fp,"479195\n");
     end
-    x = 64'h001FFFFFFFFFFFFE;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h8010000000000000;
+    ReadData1E = 64'h3FD1B49966115E41;
+    ReadData2E = 64'hBFDBFFFFFF7FFFFF;
+    ReadData3E = 64'hC3C3FFFFFFFFFFFE;
+    ans = 64'hC3C3FFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"479501\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3E96DFBD778A9099;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"479807\n");
+    end
+    ReadData1E = 64'h40A38217A755983F;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'h28D00000000040FF;
+    ans = 64'hC3F38217A755983F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"480113\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hFFF1AFE5F2357440;
+    ReadData3E = 64'h39733A3911627A6D;
+    ans = 64'hFFF9AFE5F2357440;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"480419\n");
+    end
+    ReadData1E = 64'hC3C0804000000000;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
     ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"558125\n");
+    	$fwrite(fp,"480725\n");
     end
-    x = 64'hBF80007FFFFFFFBF;
-    y = 64'hC340000000017FFE;
-    z = 64'h4010000000000001;
-    ans = 64'h42D00080000180C9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFFFFFFFFFFDFFFA;
+    ReadData2E = 64'hC1FFFFFFFFE0003F;
+    ReadData3E = 64'h3F7F675AC649130D;
+    ans = 64'h420FFFFFFFDE0FED;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"558739\n");
+    	$fwrite(fp,"481031\n");
     end
-    x = 64'h3CA0000000000000;
-    y = 64'h0000000000000001;
-    z = 64'h000E8D6AC606E59D;
-    ans = 64'h000E8D6AC606E59D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'h3FEFFFFFFE004000;
+    ans = 64'h3FEFFFFFFE004000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"559353\n");
+    	$fwrite(fp,"481337\n");
     end
-    x = 64'h403FFFFFFFFFFF76;
-    y = 64'hB7EFFFF00000007F;
-    z = 64'hC80846C2B939D9A3;
-    ans = 64'hC80846C2B939D9A3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h37E0000080000FFF;
+    ReadData2E = 64'hB926FE9CADDEFE5D;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"559967\n");
+    	$fwrite(fp,"481643\n");
     end
-    x = 64'hB7F0040001FFFFFE;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'h837FFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"560581\n");
+    	$fwrite(fp,"481949\n");
     end
-    x = 64'h3CA0000000000000;
-    y = 64'hA2DD81347EA0D30C;
-    z = 64'hBE9000000007FFFB;
-    ans = 64'hBE9000000007FFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC120000000007FFE;
+    ReadData2E = 64'h3FF0B4D0ECAA7A9E;
+    ReadData3E = 64'h414002000007FFFF;
+    ans = 64'h4137A99789BA7FDD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"561195\n");
+    	$fwrite(fp,"482255\n");
     end
-    x = 64'h3FD4FEF9A261B85F;
-    y = 64'h0010000000000000;
-    z = 64'hC1FFFFEFFFFFFFF6;
-    ans = 64'hC1FFFFEFFFFFFFF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h040FFFFFFF800FFF;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h400FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"561809\n");
+    	$fwrite(fp,"482561\n");
     end
-    x = 64'h3CA0000000000000;
-    y = 64'hC3DFFFFFFFFFFFFE;
-    z = 64'hFFF0000000000001;
+    ReadData1E = 64'hBFE000000010FFFE;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'hC180010000200000;
+    ans = 64'h433FFFFFFE21DFFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"482867\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h400A0615FD54A801;
+    ReadData3E = 64'hBFD20F1FD86CA453;
+    ans = 64'hBFD20F1FD86CA453;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"483173\n");
+    end
+    ReadData1E = 64'h801FFF00001FFFFF;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"483479\n");
+    end
+    ReadData1E = 64'hC1C000000003FFFE;
+    ReadData2E = 64'hBFF001000000003E;
+    ReadData3E = 64'h001003FFF7FFFFFF;
+    ans = 64'h41C001000004007C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"483785\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hBFEFFFFDFFBFFFFE;
+    ans = 64'hC013FFFFBFF80000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"484091\n");
+    end
+    ReadData1E = 64'h4D2FBFFFFFF80000;
+    ReadData2E = 64'hC0300FFFFF000000;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hCD6FDFBFFDFBF800;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"484397\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"484703\n");
+    end
+    ReadData1E = 64'hBFC5A1020AA218E6;
+    ReadData2E = 64'hC3E5495908A19130;
+    ReadData3E = 64'h402A691B151F3561;
+    ans = 64'h43BCC679A28B88D3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"485009\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h000D1C68E3B85FA9;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hBFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"485315\n");
+    end
+    ReadData1E = 64'hD58000FFFFFFFFEF;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h4150008000000010;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"485621\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hBF940956532022AE;
+    ReadData3E = 64'hB806C023758F4DA2;
+    ans = 64'hB806C023758F4DA2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"485927\n");
+    end
+    ReadData1E = 64'hC3E0000000040040;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"486233\n");
+    end
+    ReadData1E = 64'h3F84200000000000;
+    ReadData2E = 64'h4302931B6A82A168;
+    ReadData3E = 64'hBE2FDFFFFFFFDFFF;
+    ans = 64'h42975D087BF84F05;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"486539\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'h43EE227816B0B1FF;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"486845\n");
+    end
+    ReadData1E = 64'hBEFFFFFFFF7FFFE0;
+    ReadData2E = 64'h41EFFFFFFF5FFFFF;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'hC0FFFFFFFEDFFFDF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"487151\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'h7FF0000000000000;
     ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"562423\n");
+    	$fwrite(fp,"487457\n");
     end
-    x = 64'hC3F007F000000000;
-    y = 64'hA9AFFFFDFFFF7FFF;
-    z = 64'h47EFFF0010000000;
-    ans = 64'h47EFFF0010000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3F9FFFFFF0400000;
+    ReadData2E = 64'h3C1001DFFFFFFFFE;
+    ReadData3E = 64'h47B7CC518010305D;
+    ans = 64'h47B7CC518010305D;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"563037\n");
+    	$fwrite(fp,"487763\n");
     end
-    x = 64'h3CA0000000000000;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h8000000000000001;
-    ans = 64'h8000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'hC1DFFFFE40000000;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h3FF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"488069\n");
+    end
+    ReadData1E = 64'hC2AFFFFF80080000;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h381FFFFC0007FFFE;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"488375\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFF;
+    ReadData2E = 64'h3F94D7DCFF72CCDB;
+    ReadData3E = 64'h000FFFFFFFFFDF7F;
+    ans = 64'h0010A6BEE7FB75E6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"488681\n");
+    end
+    ReadData1E = 64'hB7E8D5DDDB5169D9;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"488987\n");
+    end
+    ReadData1E = 64'h3FEFFFFFFFDFFDFF;
+    ReadData2E = 64'hC1C939221EF1CD9B;
+    ReadData3E = 64'h4091FFFFFF000000;
+    ans = 64'hC1C9391FDED89305;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"489293\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'h41C0FFFFFFFFFDFF;
+    ans = 64'h41C0FFFFFFFFFDFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"489599\n");
+    end
+    ReadData1E = 64'h802FFFFEFFFFFFFF;
+    ReadData2E = 64'h43F00FFFFFFBFFFF;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h84300FFF7F7BFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"489905\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"490211\n");
+    end
+    ReadData1E = 64'h400FFFFFF000001F;
+    ReadData2E = 64'h3104707296E48252;
+    ReadData3E = 64'h901FFFF0003FFFFF;
+    ans = 64'h312470728CAC491A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"490517\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h0F8000000FFFDFFE;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'hBFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"490823\n");
+    end
+    ReadData1E = 64'h3F700000004FFFFF;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFF000400000000E;
+    ans = 64'hFFF800400000000E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"491129\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hFFF0080000FFFFFE;
+    ReadData3E = 64'hC00FFFFFFFFFFBBE;
+    ans = 64'hFFF8080000FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"491435\n");
+    end
+    ReadData1E = 64'h3FD408ECF56E2FA7;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hC01FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"491741\n");
+    end
+    ReadData1E = 64'h7FFFFFFFE003FFFE;
+    ReadData2E = 64'h4043FFFFFFDFFFFF;
+    ReadData3E = 64'hBFB017FFFFFFFFFF;
+    ans = 64'h7FFFFFFFE003FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"492047\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h801FFFFBFFDFFFFE;
+    ans = 64'h801FFFFBFFDFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"492353\n");
+    end
+    ReadData1E = 64'h7FDFFFFFF0FFFFFF;
+    ReadData2E = 64'hC3F0000000007FFC;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"492659\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h434FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"492965\n");
+    end
+    ReadData1E = 64'hC3C8000000008000;
+    ReadData2E = 64'hCC2000003FFFFF7E;
+    ReadData3E = 64'h800000100000000F;
+    ans = 64'h4FF8000060007F3D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"493271\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h4030800000000100;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h3FDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"493577\n");
+    end
+    ReadData1E = 64'h8010000000400000;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'hBF200000000037FE;
+    ans = 64'hBF200000000037FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"493883\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFEE952F8893D136;
+    ReadData3E = 64'h4FFFFE03FFFFFFFE;
+    ans = 64'h4FFFFE03FFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"494189\n");
+    end
+    ReadData1E = 64'hC7E007FFFFFFFFF7;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"494495\n");
+    end
+    ReadData1E = 64'h412FF7FFFFFFEFFE;
+    ReadData2E = 64'h3FD785891B76C59A;
+    ReadData3E = 64'h3A200007FFFF7FFF;
+    ans = 64'h41177FA7B92FDC24;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"494801\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'h47FFFFF7FFFFFEFE;
+    ans = 64'h47FFFFF7FFFFFEFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"495107\n");
+    end
+    ReadData1E = 64'hBFF8335B11D329F9;
+    ReadData2E = 64'hD5BFFFFFFE000200;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"495413\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hC01FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"495719\n");
+    end
+    ReadData1E = 64'h2F90000001EFFFFF;
+    ReadData2E = 64'h3CA0000000000090;
+    ReadData3E = 64'h43C63BA6AC9ACFB3;
+    ans = 64'h43C63BA6AC9ACFB3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"496025\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h3F7FF0000000FFFF;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hBCAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"496331\n");
+    end
+    ReadData1E = 64'h4030FFFFFFFDFFFF;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h3FBFFE000000FFFE;
+    ans = 64'h3FBFFE0000010086;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"496637\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FFB5677EF9DA389;
+    ReadData3E = 64'h801FF80007FFFFFF;
+    ans = 64'h0016B4EFD73B4710;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"496943\n");
+    end
+    ReadData1E = 64'hC1CFFFFF7FFFFDFE;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC00000000FFFFFC1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"497249\n");
+    end
+    ReadData1E = 64'h3FB0000000000402;
+    ReadData2E = 64'hBDF71B09ABA2E778;
+    ReadData3E = 64'h381312450C546CDA;
+    ans = 64'hBDB71B09ABA2ED42;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"497555\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFB0000800800000;
+    ans = 64'hBFB0000800800000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"497861\n");
+    end
+    ReadData1E = 64'h0020007FFFFFFE00;
+    ReadData2E = 64'h3BBC144DCA2CAA95;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"498167\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"498473\n");
+    end
+    ReadData1E = 64'hBF7FFFFFFFBFF7FF;
+    ReadData2E = 64'hBFC00001007FFFFF;
+    ReadData3E = 64'h37F521633D893DFC;
+    ans = 64'h3F500001005FFBFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"498779\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h7FFFFFFFF0007FFE;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h7FFFFFFFF0007FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"499085\n");
+    end
+    ReadData1E = 64'hC03001FFFFFBFFFF;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'h10EFFFF77FFFFFFF;
+    ans = 64'hC01001FFFFFBFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"499391\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h37FE000000000008;
+    ReadData3E = 64'h001000083FFFFFFF;
+    ans = 64'h001000083FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"499697\n");
+    end
+    ReadData1E = 64'hC86000800007FFFF;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'hC840008000080000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"500003\n");
+    end
+    ReadData1E = 64'hC1C07FFFFFDFFFFF;
+    ReadData2E = 64'hBFE5A99ACE18D898;
+    ReadData3E = 64'h401E22E2A005217B;
+    ans = 64'h41B656E7ABE704CE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"500309\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'h43EFDFFFFF800000;
+    ans = 64'h43EFDFFFFF800000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"500615\n");
+    end
+    ReadData1E = 64'h4010000100001FFF;
+    ReadData2E = 64'h40107FFFFC000000;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"500921\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"501227\n");
+    end
+    ReadData1E = 64'h3FE010003FFFFFFF;
+    ReadData2E = 64'h002473AD742511FA;
+    ReadData3E = 64'h3F33A5421650E578;
+    ans = 64'h3F33A5421650E578;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"501533\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h41580000000000FE;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h0187FFFFE00000FC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"501839\n");
+    end
+    ReadData1E = 64'h801FFF6FFFFFFFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'h40FF7FFE00000000;
+    ans = 64'h40FF7FFE00000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"502145\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h434FFFFFF7FBFFFE;
+    ReadData3E = 64'h3FA0003FFFF80000;
+    ans = 64'h3FA0003FFFF80000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"502451\n");
+    end
+    ReadData1E = 64'h4345049737D2616D;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'h4335049737D2616C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"502757\n");
+    end
+    ReadData1E = 64'hB7FFDFFFFFFFFFFF;
+    ReadData2E = 64'hC32FFE0020000000;
+    ReadData3E = 64'hCF1FF7FFFFF7FFFF;
+    ans = 64'hCF1FF7FFFFF7FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"503063\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'h018FFFFFFFFFFBF6;
+    ans = 64'h019000000FFFFDFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"503369\n");
+    end
+    ReadData1E = 64'h43F5E49AFA9FC2DA;
+    ReadData2E = 64'hB810000000000BFE;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"503675\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h3FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"503981\n");
+    end
+    ReadData1E = 64'h3FAB32343B9F34D5;
+    ReadData2E = 64'h3F800000F7FFFFFF;
+    ReadData3E = 64'hC149FFFFFFFFFFFF;
+    ans = 64'hC149FFFFFFF266E4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"504287\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hA9CFFFBFFFFFFFFB;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h000FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"504593\n");
+    end
+    ReadData1E = 64'h3F4000100000003F;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h422FF00000007FFF;
+    ans = 64'h422FF0000000803F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"504899\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC02FFFF8001FFFFE;
+    ReadData3E = 64'hB67A3E22C04C77F7;
+    ans = 64'hB67A3E22C04C77F7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"505205\n");
+    end
+    ReadData1E = 64'hB74BFFFFFFF7FFFE;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h3FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"505511\n");
+    end
+    ReadData1E = 64'hBF1FFFFBFFFFFDFF;
+    ReadData2E = 64'h41CA02C43C1F6969;
+    ReadData3E = 64'h3FEEDE240FD09F22;
+    ans = 64'hC0FA02B18CB4D85C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"505817\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'hC3FFFBF7FFFFFFFF;
+    ans = 64'hC3FFFBF7FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"506123\n");
+    end
+    ReadData1E = 64'hC013FFBFFFFFFFFF;
+    ReadData2E = 64'h3FE80000FFFFFFFF;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h4011002F60020000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"506429\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hBFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"506735\n");
+    end
+    ReadData1E = 64'hBFE000001FFFFC00;
+    ReadData2E = 64'h43DFF7FFFF000000;
+    ReadData3E = 64'hC900000001FFEFFF;
+    ans = 64'hC900000001FFEFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"507041\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h37EFFF800007FFFF;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"507347\n");
+    end
+    ReadData1E = 64'hBF8C03FFFFFFFFFE;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hC3FFFFFFFFFF7FFC;
+    ans = 64'hC3FFFFFFFFFF7FFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"507653\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC20FBFDFFFFFFFFF;
+    ReadData3E = 64'hC3F000007F7FFFFE;
+    ans = 64'hC3F000007F7FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"507959\n");
+    end
+    ReadData1E = 64'hFFFF7C5CCE30AC8C;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hFFFF7C5CCE30AC8C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"508265\n");
+    end
+    ReadData1E = 64'hC8F001FFFFFFFDFF;
+    ReadData2E = 64'h37F0001FFE000000;
+    ReadData3E = 64'h3B7CC989A4C18870;
+    ans = 64'hC0F0022001FFBDFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"508571\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'hE20A7354F18E1999;
+    ans = 64'hE20A7354F18E1999;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"508877\n");
+    end
+    ReadData1E = 64'hC03DFFFFFFFFFFF7;
+    ReadData2E = 64'hBFE38A75AE2155C3;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'h402CA39CA67E80C3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"509183\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h3FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"509489\n");
+    end
+    ReadData1E = 64'h402080000001FFFF;
+    ReadData2E = 64'h3FBFFFFFFFFFFFCF;
+    ReadData3E = 64'h43E00FFFFFFEFFFE;
+    ans = 64'h43E00FFFFFFEFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"509795\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hE40008000000000F;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"510101\n");
+    end
+    ReadData1E = 64'h43600000000040FE;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'h3F323FFFFFFFFFFE;
+    ans = 64'h43800000000040FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"510407\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h8010F897F57CA997;
+    ReadData3E = 64'h3540000100000200;
+    ans = 64'h3540000100000200;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"510713\n");
+    end
+    ReadData1E = 64'h43C800000000001F;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'h43E800000000001D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"511019\n");
+    end
+    ReadData1E = 64'hC1761E69B4B257B1;
+    ReadData2E = 64'h3F9FFFFFFEFFFE00;
+    ReadData3E = 64'hC0000001BFFFFFFF;
+    ans = 64'hC1261E6DB401D301;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"511325\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'hC3CFFFFFFFF7FF7F;
+    ans = 64'hC3CFFFFFFFF7FF7F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"511631\n");
+    end
+    ReadData1E = 64'h000C9B46C7FC9346;
+    ReadData2E = 64'h3FB0003FFFFFFFFA;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'h4000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"511937\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hBFD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"512243\n");
+    end
+    ReadData1E = 64'h3F14AB7C91DA31FD;
+    ReadData2E = 64'h401000000007FF7E;
+    ReadData3E = 64'h9DA3FFFFFFC00000;
+    ans = 64'h3F34AB7C91E48713;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"512549\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h403FF0000000003E;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"512855\n");
+    end
+    ReadData1E = 64'h83EC91CEF3FA9AAA;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'h401FC003FFFFFFFE;
+    ans = 64'h401FC003FFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"513161\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h4006FEED39B40EA1;
+    ReadData3E = 64'h37FA9D329C356AF4;
+    ans = 64'h37FA9D329C356AF4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"513467\n");
+    end
+    ReadData1E = 64'hC0BD0366D6818E16;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'hC0ED0366D6818E15;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"513773\n");
+    end
+    ReadData1E = 64'hC03E12E5D71D50F1;
+    ReadData2E = 64'hB7EF7FFF00000000;
+    ReadData3E = 64'hDD800000007BFFFF;
+    ans = 64'hDD800000007BFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"514079\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'hBEB0408E721B8F27;
+    ans = 64'hBEB0408E721B8F27;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"514385\n");
+    end
+    ReadData1E = 64'h800FFFFFFFFFFFF8;
+    ReadData2E = 64'h3DBC9CA6A89A9686;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hBFF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"514691\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'h3CAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"514997\n");
+    end
+    ReadData1E = 64'h1CA378B1AF531F03;
+    ReadData2E = 64'hC0B0000000007FDF;
+    ReadData3E = 64'h3FF00003FFFFFFEE;
+    ans = 64'h3FF00003FFFFFFEE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"515303\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h475040001FFFFFFF;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"515609\n");
+    end
+    ReadData1E = 64'h47E0000000000000;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'h40187746E35FBECD;
+    ans = 64'h4B30000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"515915\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h400000007FFFFFBE;
+    ReadData3E = 64'hC020000000C00000;
+    ans = 64'hC020000000C00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"516221\n");
+    end
+    ReadData1E = 64'hA4B00000001FFFFA;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'hA8100000001FFFF9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"516527\n");
+    end
+    ReadData1E = 64'h381FEFFFFFFFFF00;
+    ReadData2E = 64'h47E000002000000F;
+    ReadData3E = 64'h7FDFFC0000020000;
+    ans = 64'h7FDFFC0000020000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"516833\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h7FE00000003FFEFF;
+    ans = 64'h7FE00000003FFEFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"517139\n");
+    end
+    ReadData1E = 64'h43FFFFC000000004;
+    ReadData2E = 64'hC7E0001FFFFDFFFE;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'hCBEFFFFFFF7C0008;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"517445\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'h037FFFFFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"517751\n");
+    end
+    ReadData1E = 64'hBFFFDFFFFDFFFFFE;
+    ReadData2E = 64'hBFFEB4C9BBCE1AC1;
+    ReadData3E = 64'h3F8FFFFFF0002000;
+    ans = 64'h400EB614F0170029;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"518057\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h405FDFFFFFFFFFF8;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h401FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"518363\n");
+    end
+    ReadData1E = 64'hCF4FFFFFEFFFFEFF;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'h80182D1FFA57A89A;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"518669\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC22FFF77FFFFFFFF;
+    ReadData3E = 64'hC3CFFE07FFFFFFFF;
+    ans = 64'hC3CFFE07FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"518975\n");
+    end
+    ReadData1E = 64'h3FFC000000020000;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h7FEC000000020002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"519281\n");
+    end
+    ReadData1E = 64'hBD000000006FFFFE;
+    ReadData2E = 64'h41A85FEB28D8E1AF;
+    ReadData3E = 64'h3800400400000000;
+    ans = 64'hBEB85FEB2983811A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"519587\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h2F5FFFFFFFBFFFF0;
+    ans = 64'h401FFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"519893\n");
+    end
+    ReadData1E = 64'h381FFFFF7FFFFEFE;
+    ReadData2E = 64'hD92FFEFFE0000000;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hD15FFEFF6003FF7E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"520199\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'h401FFFFFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"520505\n");
+    end
+    ReadData1E = 64'h72AC000000FFFFFF;
+    ReadData2E = 64'h37E6E3CCCDE32795;
+    ReadData3E = 64'hBFB000004000003E;
+    ans = 64'h6AA4075334DDE108;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"520811\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FFF7A6C08BB70BE;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"521117\n");
+    end
+    ReadData1E = 64'h47F00010003FFFFE;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'hC7FFE00000100000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"521423\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h4017D5BA5D98B0EF;
+    ReadData3E = 64'h400FFFFFFBFFFFBF;
+    ans = 64'h400FFFFFFBFFFFBF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"521729\n");
+    end
+    ReadData1E = 64'hC003BFFFFFFFFFFF;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"522035\n");
+    end
+    ReadData1E = 64'hBFAEF1261ABA05FC;
+    ReadData2E = 64'hC1ED08B6DD3A362B;
+    ReadData3E = 64'h43E00020007FFFFF;
+    ans = 64'h43E000200081C12E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"522341\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'h480FF3FFFFFFFFFE;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"522647\n");
+    end
+    ReadData1E = 64'hC3DB82C6E85F00F3;
+    ReadData2E = 64'h333000001000003F;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"522953\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"523259\n");
+    end
+    ReadData1E = 64'hBFBFFFFFFFFFF003;
+    ReadData2E = 64'hB7EFFBFFFFC00000;
+    ReadData3E = 64'h41E000FE00000000;
+    ans = 64'h41E000FE00000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"523565\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC7EFFFF7FFFFFDFF;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'h4000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"523871\n");
+    end
+    ReadData1E = 64'hC1DFFFFFFFDE0000;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC710000003FFFFDF;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"524177\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hB2F79EF3767E3212;
+    ReadData3E = 64'hF4F3FFFFFF800000;
+    ans = 64'hF4F3FFFFFF800000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"524483\n");
+    end
+    ReadData1E = 64'hBF7800000000003F;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"524789\n");
+    end
+    ReadData1E = 64'hC012751F6F8812B9;
+    ReadData2E = 64'h41D0000000003FFE;
+    ReadData3E = 64'h7FFFFFFBFFFFFFEE;
+    ans = 64'h7FFFFFFBFFFFFFEE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"525095\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'hC0E000002000FFFE;
+    ans = 64'hC0E000002000FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"525401\n");
+    end
+    ReadData1E = 64'h37EFC00000040000;
+    ReadData2E = 64'hC3C007FFFEFFFFFF;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCA0003F9FBFFC11;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"525707\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"526013\n");
+    end
+    ReadData1E = 64'h43CFFFFFFFFEFFFC;
+    ReadData2E = 64'hC040003EFFFFFFFF;
+    ReadData3E = 64'h3FE07FFBFFFFFFFF;
+    ans = 64'hC420003EFFFF7FFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"526319\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hCFEA28B4A04A46E4;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hBFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"526625\n");
+    end
+    ReadData1E = 64'hC20FFE00000003FF;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FCFFFF000200000;
+    ans = 64'h3FCFFFF000200000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"526931\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h4CB00001FFFFFFDE;
+    ReadData3E = 64'h4030000002100000;
+    ans = 64'h4030000002100000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"527237\n");
+    end
+    ReadData1E = 64'h38101FFFC0000000;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"527543\n");
+    end
+    ReadData1E = 64'h886FFFFFFBF7FFFF;
+    ReadData2E = 64'h4003A7ECDA013DBE;
+    ReadData3E = 64'h402FFF6FFFFFFFFF;
+    ans = 64'h402FFF6FFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"527849\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'hC00FFFF000001FFE;
+    ans = 64'hC00FFFF000001FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"528155\n");
+    end
+    ReadData1E = 64'hBFCFFFFEFFFDFFFF;
+    ReadData2E = 64'h3FC0000004007FFF;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'hBF9FFFFF07FEFFBD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"528461\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"528767\n");
+    end
+    ReadData1E = 64'h3A6FFFFFFFFF7DFF;
+    ReadData2E = 64'hBFE2000007FFFFFF;
+    ReadData3E = 64'h3FCE1E88FE3E7FCE;
+    ans = 64'h3FCE1E88FE3E7FCE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"529073\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC7E1400000000000;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'h3FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"529379\n");
+    end
+    ReadData1E = 64'hBE30000003FFF7FE;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h001E000000001FFF;
+    ans = 64'h001E000002001FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"529685\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h43477310794BA290;
+    ReadData3E = 64'hC010D7F981A2B919;
+    ans = 64'hC010D7F981A2B919;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"529991\n");
+    end
+    ReadData1E = 64'h43D00000047FFFFF;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"530297\n");
+    end
+    ReadData1E = 64'h407000000000083E;
+    ReadData2E = 64'h480C00003FFFFFFF;
+    ReadData3E = 64'h7FF551A8F234313E;
+    ans = 64'h7FFD51A8F234313E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"530603\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'hBF7FFFFF80008000;
+    ans = 64'hBF7FFFFF80008000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"530909\n");
+    end
+    ReadData1E = 64'hC3D3DFFFFFFFFFFE;
+    ReadData2E = 64'hC7ECF815284B7A7C;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h4BD1FE152406E111;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"531215\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"531521\n");
+    end
+    ReadData1E = 64'hC01F7FFFFFFFFEFF;
+    ReadData2E = 64'h001FFFFFEFFFFFFF;
+    ReadData3E = 64'h4032000000000040;
+    ans = 64'h4032000000000040;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"531827\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h0B7FF7FFFC000000;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hBFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"532133\n");
+    end
+    ReadData1E = 64'h43D526C2A80AF822;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'hC7F39734008F12C8;
+    ans = 64'hC7F39734008F12C8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"532439\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hA5B000007FFF7FFF;
+    ReadData3E = 64'h3FEFC5EE1ADC8D49;
+    ans = 64'h3FEFC5EE1ADC8D49;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"532745\n");
+    end
+    ReadData1E = 64'h4036000000000000;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC020000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"533051\n");
+    end
+    ReadData1E = 64'hC13FFFFFFE0003FF;
+    ReadData2E = 64'hBFC000003FFFFBFF;
+    ReadData3E = 64'hC020000041FFFFFF;
+    ans = 64'h410FFFC07DFEF3F5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"533357\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'hC3FF80000000001F;
+    ans = 64'hC3FF80000000001F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"533663\n");
+    end
+    ReadData1E = 64'h484FFFDFFFFFBFFF;
+    ReadData2E = 64'h40001007FFFFFFFF;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'h48600FF7EFF7DFDE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"533969\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"534275\n");
+    end
+    ReadData1E = 64'hC03EFFFFFFFFFEFF;
+    ReadData2E = 64'h491BFFDFFFFFFFFE;
+    ReadData3E = 64'hA3D003FFFFFFFFFE;
+    ans = 64'hC96B1FE0FFFFFF1D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"534581\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h3FF192ACE36CC33A;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"534887\n");
+    end
+    ReadData1E = 64'hBCA010001FFFFFFE;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'h480FFE000000000F;
+    ans = 64'h480FFE000000000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"535193\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC05FFFFFF8000080;
+    ReadData3E = 64'hBD700000200001FF;
+    ans = 64'hBD700000200001FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"535499\n");
+    end
+    ReadData1E = 64'h4012E71496D6009C;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h3FFA31D6D253FEC5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"535805\n");
+    end
+    ReadData1E = 64'hFFE000001C000000;
+    ReadData2E = 64'hBF4FFFFFFF80001F;
+    ReadData3E = 64'hC0002DB970BBFE4F;
+    ans = 64'h7F4000001BC0000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"536111\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'h5A373ED6A8B003D5;
+    ans = 64'h5A373ED6A8B003D5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"536417\n");
+    end
+    ReadData1E = 64'h801FFF7FFFFFDFFF;
+    ReadData2E = 64'h401117AFD8D51332;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"536723\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"537029\n");
+    end
+    ReadData1E = 64'h182FFFFFF7FFFBFE;
+    ReadData2E = 64'h464003FF7FFFFFFF;
+    ReadData3E = 64'hC7F00004FFFFFFFE;
+    ans = 64'hC7F00004FFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"537335\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC0300000000801FE;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hBCAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"537641\n");
+    end
+    ReadData1E = 64'h000000002FFFFFFF;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'hC02000000000007E;
+    ans = 64'hC02000000000007E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"537947\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC1FFF81FFFFFFFFE;
+    ReadData3E = 64'h3FDFFFFFFFF77FFF;
+    ans = 64'h3FDFFFFFFFF77FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"538253\n");
+    end
+    ReadData1E = 64'hC7FFFFFFFFFFFBF0;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'h47EFFFFFFFFFFBF2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"538559\n");
+    end
+    ReadData1E = 64'h43EFFFFFFF7FFEFE;
+    ReadData2E = 64'hC1E0007FFE000000;
+    ReadData3E = 64'hC1EE098A9F9738A5;
+    ans = 64'hC5E0007FFDBFFD7F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"538865\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h402A0113351DAFC1;
+    ans = 64'h402A0113351DAFC1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"539171\n");
+    end
+    ReadData1E = 64'h3EC00080000001FE;
+    ReadData2E = 64'h088007FFFFFFF800;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"539477\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h400FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"539783\n");
+    end
+    ReadData1E = 64'h030C000000020000;
+    ReadData2E = 64'h3F72EFB08F55AC92;
+    ReadData3E = 64'h40DF76F22692A59F;
+    ans = 64'h40DF76F22692A59F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"540089\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hB80FFFFFFFC00001;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h001FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"540395\n");
+    end
+    ReadData1E = 64'h808E8D71D4EB26E2;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'h605B57A010AEBBA0;
+    ans = 64'h605B57A010AEBBA0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"540701\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hCAAE000000FFFFFF;
+    ReadData3E = 64'hFA00847923480522;
+    ans = 64'hFA00847923480522;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"541007\n");
+    end
+    ReadData1E = 64'hFFE000007FBFFFFE;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h7FE000007FBFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"541313\n");
+    end
+    ReadData1E = 64'h402FFFFFFFFDFFFE;
+    ReadData2E = 64'h3FDC00000001FFFF;
+    ReadData3E = 64'h3FFFC00000400000;
+    ans = 64'h4021F80000081FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"541619\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h41BE6A4FDAD1844F;
+    ans = 64'h41BE6A4FDAD1844F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"541925\n");
+    end
+    ReadData1E = 64'hC6A0000000080007;
+    ReadData2E = 64'hFFD0000000088000;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"542231\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hC000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"542537\n");
+    end
+    ReadData1E = 64'h4604C11700626B2B;
+    ReadData2E = 64'h3CAA520793793965;
+    ReadData3E = 64'h3FCFFFFF00001FFF;
+    ans = 64'h42C1121665239C7D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"542843\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h7FFFFFFFFFFFFA00;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h7FFFFFFFFFFFFA00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"543149\n");
+    end
+    ReadData1E = 64'hC03FF7FFFFFFFF7F;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC3FFFFF8000003FF;
+    ans = 64'hC3FFFFF8000003FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"543455\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC3F0000003F7FFFF;
+    ReadData3E = 64'h34CC2F99040AE502;
+    ans = 64'h34CC2F99040AE502;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"543761\n");
+    end
+    ReadData1E = 64'h3F3FE00000000000;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hBFF003FC00000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"544067\n");
+    end
+    ReadData1E = 64'h37F000000DFFFFFF;
+    ReadData2E = 64'h47F00000000043FF;
+    ReadData3E = 64'hC07FFFFFFEFFFFBE;
+    ans = 64'hC07FEFFFFEF1FF7A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"544373\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'hBF8961BE48C37E82;
+    ans = 64'hBF8961BE48C37E82;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"544679\n");
+    end
+    ReadData1E = 64'hBFE2083CCB3D47F8;
+    ReadData2E = 64'h43D0443E6399E6DF;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'hC3C265261DC90B18;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"544985\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h3FF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"545291\n");
+    end
+    ReadData1E = 64'h434F8000FFFFFFFF;
+    ReadData2E = 64'h406FFFFC007FFFFF;
+    ReadData3E = 64'h4010007FFFFFC000;
+    ans = 64'h43CF7FFD107DE002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"545597\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC3DFFC0003FFFFFE;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'h840FFC0003FFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"545903\n");
+    end
+    ReadData1E = 64'h2F30001FFEFFFFFF;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'hC1062003748F8F29;
+    ans = 64'hC1062003748F8F29;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"546209\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC07FF7FFFFFFFF7F;
+    ReadData3E = 64'h3F90000000201FFE;
+    ans = 64'h3F90000000201FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"546515\n");
+    end
+    ReadData1E = 64'h801FFFFFEE000000;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h3FDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"546821\n");
+    end
+    ReadData1E = 64'h3FCFFFFFEEFFFFFF;
+    ReadData2E = 64'hB7FFFFFFF7FFFFEF;
+    ReadData3E = 64'hB89FFF00000FFFFF;
+    ans = 64'hB8A00080000737FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"547127\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'hC0B0000000081FFF;
+    ans = 64'hC0B0000000081FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"547433\n");
+    end
+    ReadData1E = 64'h3C4FF00040000000;
+    ReadData2E = 64'hBFCFFFFFFE00007E;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h4010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"547739\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hBFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"548045\n");
+    end
+    ReadData1E = 64'hC020000000040007;
+    ReadData2E = 64'h3469DC294133AA1B;
+    ReadData3E = 64'hC3DFE000000007FE;
+    ans = 64'hC3DFE000000007FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"548351\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hBCCCC98E4AA02611;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"548657\n");
+    end
+    ReadData1E = 64'h3D46FFFFFFFFFFFF;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FC31D5708AC8D44;
+    ans = 64'h3FC31D5708ABD544;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"548963\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC70000007F7FFFFF;
+    ReadData3E = 64'hFFD000047FFFFFFF;
+    ans = 64'hFFD000047FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"549269\n");
+    end
+    ReadData1E = 64'h3A5FFFF007FFFFFE;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'hBFD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"549575\n");
+    end
+    ReadData1E = 64'hC040000003FFFFFB;
+    ReadData2E = 64'hBDA000FFFBFFFFFF;
+    ReadData3E = 64'hC3F1B104FF39AF76;
+    ans = 64'hC3F1B104FF39AF76;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"549881\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'hB7FFE0000001FFFE;
+    ans = 64'hB7FFE0000001FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"550187\n");
+    end
+    ReadData1E = 64'h7FFF8000000FFFFE;
+    ReadData2E = 64'hB7EDCF2899E0A641;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'h7FFF8000000FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"550493\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h3FDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"550799\n");
+    end
+    ReadData1E = 64'h405F100000000000;
+    ReadData2E = 64'h1EA0001FF7FFFFFF;
+    ReadData3E = 64'hC34FFFE0001FFFFF;
+    ans = 64'hC34FFFE0001FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"551105\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h41D55E87D7361155;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"551411\n");
+    end
+    ReadData1E = 64'h43C0FFFFFFFFFFF0;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'h027FFFFFFBFFFFFC;
+    ans = 64'hC720FFFFFFFFFFEF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"551717\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC1A000000000FEFF;
+    ReadData3E = 64'hBFD0FFFDFFFFFFFF;
+    ans = 64'hBFD0FFFDFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"552023\n");
+    end
+    ReadData1E = 64'hFFF84054BAD6D8D0;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'hFFF84054BAD6D8D0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"552329\n");
+    end
+    ReadData1E = 64'h001F800000000004;
+    ReadData2E = 64'h40CFFFFFFFF7FEFE;
+    ReadData3E = 64'hC3DFFFBBFFFFFFFE;
+    ans = 64'hC3DFFFBBFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"552635\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFD000000800000F;
+    ans = 64'hBFD000000800000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"552941\n");
+    end
+    ReadData1E = 64'hBFBFFFBFFFFDFFFF;
+    ReadData2E = 64'h80200FFFFFFFFFFB;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"553247\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'hC010FFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"553553\n");
+    end
+    ReadData1E = 64'h2EE0003FFFFC0000;
+    ReadData2E = 64'hC3C00000FFF7FFFF;
+    ReadData3E = 64'h3E8FFFFFFFFFFFEF;
+    ans = 64'h3E8FFFFFFFFFFFEF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"553859\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h431C03FFFFFFFFFF;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"554165\n");
+    end
+    ReadData1E = 64'hC030000000000FBF;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'h3FDEE29310989E27;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"554471\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h44D000003FFDFFFE;
+    ReadData3E = 64'h3D2000000000FFBF;
+    ans = 64'h3D2000000000FFBF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"554777\n");
+    end
+    ReadData1E = 64'h401FF7BFFFFFFFFE;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"555083\n");
+    end
+    ReadData1E = 64'h401FFFBFFFFFFFFC;
+    ReadData2E = 64'hC0000000000100FF;
+    ReadData3E = 64'h3FDB0C7F1AA6DCB7;
+    ans = 64'hC02F275C072CCB10;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"555389\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FDFC00003FFFFFF;
+    ans = 64'h7FDFC00003FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"555695\n");
+    end
+    ReadData1E = 64'hC3EFFFFFEFFFDFFE;
+    ReadData2E = 64'hB7F0000000FFEFFF;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"556001\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"556307\n");
+    end
+    ReadData1E = 64'h380FFFBFFE000000;
+    ReadData2E = 64'h47F1301F5B57A021;
+    ReadData3E = 64'hC7FFFF800000000F;
+    ans = 64'hC7FFFF800000000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"556613\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h002FFFFFFFFFFEF6;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"556919\n");
+    end
+    ReadData1E = 64'h73D9FCECC51EB691;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'hC1C0000000003FBE;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"557225\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'h403000001FFFFFFD;
+    ReadData3E = 64'h480007FFEFFFFFFF;
+    ans = 64'h480007FFEFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"557531\n");
+    end
+    ReadData1E = 64'h40D0007FFFE00000;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"557837\n");
+    end
+    ReadData1E = 64'hC03243999D53ABF6;
+    ReadData2E = 64'h345000002001FFFF;
+    ReadData3E = 64'hB8900403FFFFFFFF;
+    ans = 64'hB8900403FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"558143\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFCA7F53316EAB07;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"558449\n");
+    end
+    ReadData1E = 64'h4020080000000FFE;
+    ReadData2E = 64'h755FFFFFFFFF5FFF;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h759007FFFFFFBFD5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"558755\n");
+    end
+    ReadData1E = 64'h001FFFFFFFFFFFFE;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"559061\n");
+    end
+    ReadData1E = 64'h3E37118D48FFBADF;
+    ReadData2E = 64'h3CA0000000800000;
+    ReadData3E = 64'h401FFFF7FFFFFFC0;
+    ans = 64'h401FFFF7FFFFFFC0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"559367\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hDB63FFF7FFFFFFFF;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'hD813FFF7FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"559673\n");
+    end
+    ReadData1E = 64'h434000000007FFEF;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'h43EFFFFFFFFFFFFF;
+    ans = 64'h43EFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"559979\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h4BB2000000004000;
+    ReadData3E = 64'h43C5EE619EB6C788;
+    ans = 64'h4862000000004000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"560285\n");
+    end
+    ReadData1E = 64'h4007000000000000;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h0000000000000003;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"560591\n");
+    end
+    ReadData1E = 64'h002200000000003F;
+    ReadData2E = 64'h3FCFFFFFFF0000FE;
+    ReadData3E = 64'hC3CB85B401C44430;
+    ans = 64'hC3CB85B401C44430;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"560897\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'hAEC0000020000000;
+    ans = 64'hAEC0000020000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"561203\n");
+    end
+    ReadData1E = 64'hBFC004000001FFFF;
+    ReadData2E = 64'hCD600000003C0000;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'h4D300400003E0EFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"561509\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'h000FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"561815\n");
+    end
+    ReadData1E = 64'h37FFFFBFFFFFFBFE;
+    ReadData2E = 64'hBCAFFFFF7FFFFFBE;
+    ReadData3E = 64'hB28400000000001F;
+    ans = 64'hB4BFFFBF80037BBC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"562121\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hB800000001000FFE;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hC00FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"562427\n");
+    end
+    ReadData1E = 64'h3FD4FEF9A261B85F;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'hC1FFFFEFFFFFFFF6;
+    ans = 64'hC1FFFFEFFFFFFFF6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"562733\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h41EFFFFFFFFFF00F;
+    ReadData3E = 64'h7FFFFFFFFFC0001F;
+    ans = 64'h7FFFFFFFFFC0001F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"563039\n");
+    end
+    ReadData1E = 64'hC3C0000000003FFD;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"563345\n");
+    end
+    ReadData1E = 64'h7FF4760C8E5F3973;
+    ReadData2E = 64'hCC9FFFF87FFFFFFE;
+    ReadData3E = 64'hB80FFE007FFFFFFE;
+    ans = 64'h7FFC760C8E5F3973;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
@@ -43185,7189 +71866,11971 @@ initial
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
     	$fwrite(fp,"563651\n");
     end
-    x = 64'h403FFFFF8007FFFF;
-    y = 64'hC1D000001FFFFFDF;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'hC21FFFFFBFF7FEBD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'h3FB0010000000007;
+    ans = 64'h3FB0010000000007;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"564265\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h3CA0000000000000;
-    z = 64'h4E60000001FFFF7F;
-    ans = 64'h4E60000001FFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"564879\n");
-    end
-    x = 64'h37F000000037FFFE;
-    y = 64'h3CAFFFC000000008;
-    z = 64'hCC40000800003FFE;
-    ans = 64'hCC40000800003FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"565493\n");
-    end
-    x = 64'h001FFFF7FFFDFFFF;
-    y = 64'h3CA0000000000001;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"566107\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hBF3FF7FFFFFEFFFF;
-    z = 64'h33DFFFFFF00003FE;
-    ans = 64'hBBEFF7FFFFFEFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"566721\n");
-    end
-    x = 64'hFFDFFF7FFFFFFDFF;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hC3D0000000000780;
-    ans = 64'hFC9FFF7FFFFFFDFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"567335\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hC02B75AA8C7CE7CF;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"567949\n");
-    end
-    x = 64'h3DAA778B91CB7508;
-    y = 64'h41DDE00000000000;
-    z = 64'hA5A5E0EEE55BDC4F;
-    ans = 64'h3F98B59B4D1CF242;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"568563\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h3FD0000000000001;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"569177\n");
-    end
-    x = 64'hC0B2B61F5E89F40A;
-    y = 64'h3FE0001FFFFFFDFF;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'hC0A2B244CAC8AEC6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"569791\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hC1E00000000010FF;
-    ans = 64'hC1E00000000010FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"570405\n");
-    end
-    x = 64'hBEDBFF0000000000;
-    y = 64'h41CFFFFFFFFFFF7F;
-    z = 64'hC80000000FFFFFEE;
-    ans = 64'hC80000000FFFFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"571019\n");
-    end
-    x = 64'hC1F000000401FFFE;
-    y = 64'h3FE0000000000000;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'hC1E000000401FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"571633\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h3FDFFFAFFFFFFFFF;
-    z = 64'h802FA574C852AFD8;
-    ans = 64'h3C8FFFAFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"572247\n");
-    end
-    x = 64'h3FD0010000020000;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h3A4FFEFFFFFDFFFE;
-    ans = 64'h3FD001000001FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"572861\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h3FD04001FFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"573475\n");
-    end
-    x = 64'hC1D0000007FFFFBE;
-    y = 64'h41A03FFFF0000000;
-    z = 64'h41CFFFFFFC000100;
-    ans = 64'hC3803FFFF61FFFB5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"574089\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h3FF0000000000000;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"574703\n");
-    end
-    x = 64'h7FD000000000400F;
-    y = 64'hFD5FFFDFFE000000;
-    z = 64'h3FF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"575317\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hC34FFFFFFDFFFFFD;
-    ans = 64'hC34FFFFFFDFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"575931\n");
-    end
-    x = 64'hB60FF7FFFF7FFFFF;
-    y = 64'h3F0F0000000007FF;
-    z = 64'h40101FFFDFFFFFFF;
-    ans = 64'h40101FFFDFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"576545\n");
-    end
-    x = 64'hC3EFFFFFFFF7FBFE;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h8010000000000000;
-    ans = 64'hC3FFFFFFFFF7FBFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"577159\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hAC9FFFFFFFF80000;
-    z = 64'h40EFFFFFFFFFF77F;
-    ans = 64'h40EFFFFFFFFFF77F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"577773\n");
-    end
-    x = 64'h07B00000007FFFFE;
-    y = 64'h4000000000000001;
-    z = 64'h3B20000000FEFFFE;
-    ans = 64'h3B20000000FEFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"578387\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h002FC000000000FF;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"579001\n");
-    end
-    x = 64'h3CCFF7FFFFFBFFFF;
-    y = 64'hBA90000100000080;
-    z = 64'h41E00000007FF7FF;
-    ans = 64'h41E00000007FF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"579615\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"580229\n");
-    end
-    x = 64'hBFCFFFFFFFF3FFFF;
-    y = 64'h40100000000100FF;
-    z = 64'h3FE0000000000001;
-    ans = 64'hBFDFFFFFFFEC03F8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"580843\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h4010000000000000;
-    z = 64'h407FFFFC1FFFFFFE;
-    ans = 64'h407FFFFC1FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"581457\n");
-    end
-    x = 64'h43C047F600C3F7AA;
-    y = 64'h3732487BBFBF6EAC;
-    z = 64'hBFFFFFFFFFFFFDFB;
-    ans = 64'hBFFFFFFFFFFFFDFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"582071\n");
-    end
-    x = 64'hFFF0080000001FFE;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h8000000000000001;
-    ans = 64'hFFF8080000001FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"582685\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h3CAE2400053CB0F9;
-    z = 64'hBF8FFFFFFFFDDFFE;
-    ans = 64'hBF8FFFFFFFFDDFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"583299\n");
-    end
-    x = 64'hC00FE00000000FFF;
-    y = 64'h4340000000000000;
-    z = 64'hBFEBFFC000000000;
-    ans = 64'hC35FE00000000FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"583913\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hC0800003FFF80000;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000041;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"584527\n");
-    end
-    x = 64'hBFBFFFFFFFDFFFFE;
-    y = 64'h3FD01000001FFFFF;
-    z = 64'hBF9FFFFFFF803FFE;
-    ans = 64'hBFB007FFFFE807FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"585141\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"585755\n");
-    end
-    x = 64'h47BFFFFFFFC00800;
-    y = 64'hC0500007FFFFBFFF;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'hC8200007FFDFC3EF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"586369\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hC019CAB46F8C90A7;
-    ans = 64'hC011CAB46F8C90A8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"586983\n");
-    end
-    x = 64'h8020200000000080;
-    y = 64'h4C9FE00000010000;
-    z = 64'hBFE000013FFFFFFF;
-    ans = 64'hBFE000013FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"587597\n");
-    end
-    x = 64'h43D0000000007BFF;
-    y = 64'h7FE0000000000001;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"588211\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hB09002000000003E;
-    z = 64'h37F002000000001F;
-    ans = 64'h37F002000000001F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"588825\n");
-    end
-    x = 64'h43CFFFFC00400000;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h380FFFFFFFFFFBFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"589439\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h41EBFF0000000000;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFC801FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"590053\n");
-    end
-    x = 64'h400F800FFFFFFFFF;
-    y = 64'hA991FFFFFFC00000;
-    z = 64'hC15DFFFFFFFDFFFE;
-    ans = 64'hC15DFFFFFFFDFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"590667\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h7FF0000000000001;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"591281\n");
-    end
-    x = 64'hBCAC000003FFFFFF;
-    y = 64'hC3C00080000003FF;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h407C00E0040026FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"591895\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h4103E839DCCFFAEF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"592509\n");
-    end
-    x = 64'hAEA03FFFFFFFFFFD;
-    y = 64'h800FFFFFFFF7BFFF;
-    z = 64'h801000007FFFFE00;
-    ans = 64'h801000007FFFFE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"593123\n");
-    end
-    x = 64'h43CFFFFE0001FFFF;
-    y = 64'h8000000000000000;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"593737\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hC000002000000FFF;
-    z = 64'hB37EFDFFFFFFFFFF;
-    ans = 64'hBCB0002000000FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"594351\n");
-    end
-    x = 64'h47EFC142A7AA9FC5;
-    y = 64'h8000000000000001;
-    z = 64'hBFA36F59B827AA2E;
-    ans = 64'hBFA36F59B827AA2E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"594965\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hBFC0FFFFFFFFFFEF;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"595579\n");
-    end
-    x = 64'h3CAFFBFFFFFFFF7F;
-    y = 64'h7FFFFC0000000008;
-    z = 64'hC1CFFFC0003FFFFE;
-    ans = 64'h7FFFFC0000000008;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"596193\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h8010000000000000;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"596807\n");
-    end
-    x = 64'h37FFFFFFFFDFFC00;
-    y = 64'h400F7FFFFFFF7FFF;
-    z = 64'h3CA0000000000000;
-    ans = 64'h3CA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"597421\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h8010000000000001;
-    z = 64'hC1A000000000080F;
-    ans = 64'hC1A000000000080F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"598035\n");
-    end
-    x = 64'h3FA0000003FFFFEE;
-    y = 64'h3FB8B9A055DED013;
-    z = 64'hBC0FFFFFF0020000;
-    ans = 64'h3F68B9A05C0D380C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"598649\n");
-    end
-    x = 64'hC03FBFFFFFFFF800;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"599263\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hC0B87E66EFF0F1FE;
-    z = 64'hC3E000FFFFFEFFFF;
-    ans = 64'hC3E000FFFFFEFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"599877\n");
-    end
-    x = 64'h001400000000001F;
-    y = 64'hBCA0000000000000;
-    z = 64'hDA2B647026EEBA96;
-    ans = 64'hDA2B647026EEBA96;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"600491\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h1F30403FFFFFFFFF;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"601105\n");
-    end
-    x = 64'hC1C5EEED585AABCE;
-    y = 64'h400FFFFFF77FFFFE;
-    z = 64'h480FF08000000000;
-    ans = 64'h480FF08000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"601719\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"602333\n");
-    end
-    x = 64'h3B4B2B5E46FAE16F;
-    y = 64'hC1EC0007FFFFFFFF;
-    z = 64'h0010000000000001;
-    ans = 64'hBD47C5F948F316FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"602947\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hBFD0000000000000;
-    z = 64'h3E90D05E2957F142;
-    ans = 64'h3E90D05E294FF142;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"603561\n");
-    end
-    x = 64'hBFDF80003FFFFFFF;
-    y = 64'hBFB003FFFEFFFFFF;
-    z = 64'h3CAFFE0000000200;
-    ans = 64'h3F9F87E03E180039;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"604175\n");
-    end
-    x = 64'hB7EFFFFFFE00000F;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"604789\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h3F90000080FFFFFE;
-    z = 64'hC03000000010007E;
-    ans = 64'hC03000000010007E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"605403\n");
-    end
-    x = 64'hB805AF0434902F3C;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h478B9FDB62B52236;
-    ans = 64'h478B9FDB62B52236;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"606017\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h402E00001FFFFFFF;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFDFFFFFFFFFFFE4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"606631\n");
-    end
-    x = 64'hBFCFFFFF6FFFFFFE;
-    y = 64'h4052E8AF709A9CA0;
-    z = 64'hC17003FFFFFFFFE0;
-    ans = 64'hC17004012E8AF198;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"607245\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"607859\n");
-    end
-    x = 64'h43443177992F047A;
-    y = 64'hBFCD6E643DF27728;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hC322927DAF9E39A7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"608473\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hBFFFFF7FFFFFE000;
-    ans = 64'hBFFFFF7FFFFFE000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"609087\n");
-    end
-    x = 64'hFFDF8000000003FE;
-    y = 64'h7FE0000000040200;
-    z = 64'hC1EFFE0000000FFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"609701\n");
-    end
-    x = 64'h47DF0FB4968EC67D;
-    y = 64'hBFF0000000000001;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'hC7DF0FB4968EC67F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"610315\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h40C0040004000000;
-    z = 64'h40071DA282D7133B;
-    ans = 64'h40071DA282D71B3D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"610929\n");
-    end
-    x = 64'h801FFFFFFFFFBFEF;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hC80FEFFFEFFFFFFF;
-    ans = 64'hC80FEFFFEFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"611543\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h434FFFFFFEFFFDFF;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'h3FF7FFFFFEFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"612157\n");
-    end
-    x = 64'hBF90000FFFFFFFFF;
-    y = 64'hBF13C4AABD3B8972;
-    z = 64'h802FFFE0007FFFFF;
-    ans = 64'h3EB3C4BE81E646AC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"612771\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hC000000000000001;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"613385\n");
-    end
-    x = 64'hA333A1B8F786C499;
-    y = 64'h3E6FFFFF007FFFFE;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"613999\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h43F001FFC0000000;
-    ans = 64'h43F001FFC0000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"614613\n");
-    end
-    x = 64'hFFD0809EC4FE2D71;
-    y = 64'hBFA4C050535BFCCB;
-    z = 64'h4427ED571629ABB8;
-    ans = 64'h7F856720C08D93C5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"615227\n");
-    end
-    x = 64'h47FFFFFFFFFF8400;
-    y = 64'hC010000000000000;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'hC81FFFFFFFFF8400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"615841\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hC3FFBFFFFFFFFFFF;
-    z = 64'h419FC00000000040;
-    ans = 64'h419FBFC080000040;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"616455\n");
-    end
-    x = 64'h3FC412D60269F292;
-    y = 64'hC010000000000001;
-    z = 64'hC1E476A2F395D532;
-    ans = 64'hC1E476A2F3A9E808;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"617069\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hC03836C73E52BECA;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBCEA36C73E52BECA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"617683\n");
-    end
-    x = 64'hC1FFFEFFFFFFFF00;
-    y = 64'hD1540000000FFFFF;
-    z = 64'hC1FF6A7F749999AB;
-    ans = 64'h5363FF60000FFEDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"618297\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hC340000000000000;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"618911\n");
-    end
-    x = 64'h3FD78110F038153D;
-    y = 64'h682FFFE000008000;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"619525\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hC340000000000001;
-    z = 64'hC2BFFFFFFFFC07FE;
-    ans = 64'hC2BFFFFFFFFC08FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"620139\n");
-    end
-    x = 64'h410002007FFFFFFE;
-    y = 64'h41801EFFFFFFFFFF;
-    z = 64'hC3FCB59067D08B65;
-    ans = 64'hC3FCB590274C79E1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"620753\n");
-    end
-    x = 64'hC3DFFFFFEFFFFFF6;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h4000000000000000;
-    ans = 64'h473FFFFFEFFFFFF4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"621367\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hBE9FFFFFFC03FFFF;
-    z = 64'h7FF00002000003FF;
-    ans = 64'h7FF80002000003FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"621981\n");
-    end
-    x = 64'h41F0000040000FFF;
-    y = 64'hFFE0000000000000;
-    z = 64'h37E00000FFDFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"622595\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hECB7B942F9055E17;
-    z = 64'hBCA0000000000000;
-    ans = 64'hE967B942F9055E17;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"623209\n");
-    end
-    x = 64'hBFBFFFFFBFFFFBFE;
-    y = 64'h403FF80000000FFF;
-    z = 64'hB7EFFC0000000800;
-    ans = 64'hC00FF7FFC0100BFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"623823\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h3FD0000000000000;
-    ans = 64'hFC9FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"624437\n");
-    end
-    x = 64'h3CAFFFFFFFFFBC00;
-    y = 64'hC0DFFF7FFFFFFFF7;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"625051\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'hFFF0000000000000;
-    z = 64'h3D696CE5B4272424;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"625665\n");
-    end
-    x = 64'hB789E111956BE9EB;
-    y = 64'hFA7FFDFFFFFBFFFF;
-    z = 64'h37B0085F71B84DC0;
-    ans = 64'h7219DF73844F5709;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"626279\n");
-    end
-    x = 64'hC007C6480B50CE31;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h3FF0000000000001;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"626893\n");
-    end
-    x = 64'h3CA0000000000000;
-    y = 64'h40E0001FF7FFFFFF;
-    z = 64'hB7FD3409DC18DB9B;
-    ans = 64'h3D90001FF7FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"627507\n");
-    end
-    x = 64'hB6B00000000023FF;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h381FFFFFFE000000;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"628121\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hBFCC0DA6851DE8E0;
-    z = 64'h8010000000000001;
-    ans = 64'hBC7C0DA6851DE8E2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"628735\n");
-    end
-    x = 64'h2CFFFFFFBBFFFFFF;
-    y = 64'hC03FFFFFFFFDFFFB;
-    z = 64'hC0E07FFF00000000;
-    ans = 64'hC0E07FFF00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"629349\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3CA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"629963\n");
-    end
-    x = 64'hC281AA5C3F9C8D6D;
-    y = 64'h480FFFFFC007FFFE;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hCAA1AA5C1C4C3F84;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"630577\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h001E0000001FFFFF;
-    ans = 64'h001E0000001FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"631191\n");
-    end
-    x = 64'h7FFFFFFFFFFFFF76;
-    y = 64'h37E4A237FD281C2D;
-    z = 64'h37E0004000FFFFFF;
-    ans = 64'h7FFFFFFFFFFFFF76;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"631805\n");
-    end
-    x = 64'hCCDD9073C4CA0F6E;
-    y = 64'h0010000000000001;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"632419\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h4030007BFFFFFFFE;
-    z = 64'h00200040003FFFFE;
-    ans = 64'h3CE0007BFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"633033\n");
-    end
-    x = 64'h45D001FFFFFF0000;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h00240000007FFFFF;
-    ans = 64'h060001FFFFFEFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"633647\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hB0F1000000FFFFFF;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'hADA1000001000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"634261\n");
-    end
-    x = 64'h40C0200000000003;
-    y = 64'h3E9173C34A679357;
-    z = 64'hFFF1FFF7FFFFFFFE;
-    ans = 64'hFFF9FFF7FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"634875\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h3CA0000000000001;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h3950000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"635489\n");
-    end
-    x = 64'hBB5FDFFFFFF7FFFE;
-    y = 64'h8021FEFFFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"636103\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h401FFFFFFEDFFFFF;
-    ans = 64'h401FFFFFFEDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"636717\n");
-    end
-    x = 64'h402FFFFFFFFDDFFE;
-    y = 64'h3F8FFFFFFFFF000F;
-    z = 64'h406FFBFFFFDFFFFF;
-    ans = 64'h407001FFFFEFFF9C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"637331\n");
-    end
-    x = 64'h41F0060000000000;
-    y = 64'h3FD0000000000000;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h41D0060000200000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"637945\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hBF30004000200000;
-    z = 64'h16F1FFFFFFFBFFFF;
-    ans = 64'hBBE0004000200001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"638559\n");
-    end
-    x = 64'hC00FBEFFFFFFFFFF;
-    y = 64'h3FD0000000000001;
-    z = 64'hC1E1FFFFFFFFF7FE;
-    ans = 64'hC1E20000001FB6FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"639173\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h45EE000000000010;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"639787\n");
-    end
-    x = 64'h3CAF000000010000;
-    y = 64'h40CD9821F2214351;
-    z = 64'h3FEBFFFFFFFFFE00;
-    ans = 64'h3FEC0000000070AE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"640401\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h3FE0000000000000;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h3C90000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"641015\n");
-    end
-    x = 64'hC11FFFF800007FFF;
-    y = 64'h4342C5257254E48E;
-    z = 64'hC010000000000000;
-    ans = 64'hC472C520C10BD30D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"641629\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h3FE0000000000001;
-    z = 64'hC02F53C96958BA00;
-    ans = 64'hC02F53C96958BA00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"642243\n");
-    end
-    x = 64'hC3FFFFFFFC1FFFFF;
-    y = 64'h480FFFFFF8008000;
-    z = 64'hBDE00008007FFFFF;
-    ans = 64'hCC1FFFFFF4208000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"642857\n");
-    end
-    x = 64'hB8020CD4671337DF;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"643471\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h432000000FEFFFFF;
-    z = 64'h43F0001BFFFFFFFF;
-    ans = 64'h43F0001BFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"644085\n");
-    end
-    x = 64'hBFFDB0D21ABE9560;
-    y = 64'h3FF0000000000000;
-    z = 64'hB808F2DEE31A0781;
-    ans = 64'hBFFDB0D21ABE9560;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"644699\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h3E295BE2AB58A5F9;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"645313\n");
+    	$fwrite(fp,"563957\n");
     end
-    x = 64'hFCC00000040FFFFF;
-    y = 64'hC3E0A8C598700473;
-    z = 64'hFFE000001FBFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h403A7713E8818439;
+    ReadData2E = 64'h800FFFFFFFFFFFCF;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h3CAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"645927\n");
+    	$fwrite(fp,"564263\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h0000000000000000;
-    ans = 64'h3CB0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h0000000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"646541\n");
+    	$fwrite(fp,"564569\n");
     end
-    x = 64'h001FFFFFFFFFFFE2;
-    y = 64'hC1FFC000000000FE;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC0144254342743BB;
+    ReadData2E = 64'hB1F20FFFFFFFFFFF;
+    ReadData3E = 64'hBE1FFFFFFFFFFFC1;
+    ans = 64'hBE1FFFFFFFFFFFC1;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"647155\n");
+    	$fwrite(fp,"564875\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'h4000000000000000;
-    z = 64'h3FDFEFFFFC000000;
-    ans = 64'h3FDFEFFFFC000004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h4340080000000002;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'h4008040000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"647769\n");
+    	$fwrite(fp,"565181\n");
     end
-    x = 64'hC3FFFFFFEFFFFFFB;
-    y = 64'h80200007FFFBFFFF;
-    z = 64'h41D01FFFFFE00000;
-    ans = 64'h41D01FFFFFE00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBDA000000001FF7F;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'h41C0003FFFFFFFFE;
+    ans = 64'h41C0003FFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"648383\n");
+    	$fwrite(fp,"565487\n");
     end
-    x = 64'hC0300081FFFFFFFF;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h3CA0000000000001;
-    ans = 64'hC0500081FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC1EFFFFE0003FFFF;
+    ReadData3E = 64'h4CC0807FFFFFFFFE;
+    ans = 64'h4CC0807FFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"648997\n");
+    	$fwrite(fp,"565793\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'hBFE000000FFFDFFF;
-    z = 64'h3FEE60AF9E2E4B00;
-    ans = 64'h3FEE60AF9E2E4AFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h6911007FFFFFFFFE;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"649611\n");
+    	$fwrite(fp,"566099\n");
     end
-    x = 64'hBFDFFFFFFFCFFFFF;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h002FFFFFF7FFFFFF;
-    ans = 64'hBFFFFFFFFFCFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC25FFFFFFFFF6FFF;
+    ReadData2E = 64'h408FFFFFFFFC000F;
+    ReadData3E = 64'h41DFFFFFFFC000FF;
+    ans = 64'hC2FFFFF7FFFB701E;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"650225\n");
+    	$fwrite(fp,"566405\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'h61BFE01FFFFFFFFF;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h405CB2EDB604D8DE;
+    ans = 64'h405CB2EDB604D8DE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"650839\n");
+    	$fwrite(fp,"566711\n");
     end
-    x = 64'h44820F5D13A0271D;
-    y = 64'hC34FFFEFFFFBFFFF;
-    z = 64'hC3E0000FFFE00000;
-    ans = 64'hC7E20F540BEF5B61;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3ED003FF7FFFFFFF;
+    ReadData2E = 64'h3A0D68E6205F2D62;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hBCA0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"651453\n");
+    	$fwrite(fp,"567017\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'h4010000000000001;
-    z = 64'hFFF0000000000001;
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'hFFF0000000000001;
     ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"652067\n");
+    	$fwrite(fp,"567323\n");
     end
-    x = 64'hC01B78321869F7BE;
-    y = 64'hBFCFFFFFF6FFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFD21F37BD3F5963;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h002FFFFFFF00000F;
+    ReadData2E = 64'h380000FFFFFFC000;
+    ReadData3E = 64'h800B8F38D5581BB9;
+    ans = 64'h800B8F38D5581BB9;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"652681\n");
+    	$fwrite(fp,"567629\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h57A0008000000400;
-    ans = 64'h57A0008000000400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBFB7317BC451054B;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hBFF0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"653295\n");
+    	$fwrite(fp,"567935\n");
     end
-    x = 64'h47F0FFFFFFFFFFFE;
-    y = 64'hBFCFF00000800000;
-    z = 64'hC0800000201FFFFF;
-    ans = 64'hC7D0F7800043FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h401FE1EDC4F937A1;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'hD8EBE3EE3DA505F1;
+    ans = 64'hD8EBE3EE3DA505F1;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"653909\n");
+    	$fwrite(fp,"568241\n");
     end
-    x = 64'h000FFFFFFFFFFFF0;
-    y = 64'h4340000000000001;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h035FFFFFFFFFFFE4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC3E2000000004000;
+    ReadData3E = 64'h41EFFFFFFFFF1FFE;
+    ans = 64'h41EFFFFF6FFF1FFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"654523\n");
+    	$fwrite(fp,"568547\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'h7FD5CF6583F3D781;
-    z = 64'hC03FFFFFFFFBFFFE;
-    ans = 64'h7C85CF6583F3D782;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hCEAFFFFC7FFFFFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hCB6FFFFC7FFFFFFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"655137\n");
+    	$fwrite(fp,"568853\n");
     end
-    x = 64'hBFC0000004000007;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hC3CFFFDFFFBFFFFE;
-    ans = 64'hC3D001EFFFE07FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h5150200000000003;
+    ReadData2E = 64'h41EA317A7FF8829C;
+    ReadData3E = 64'h3FC3FFFFFFFFFFFC;
+    ans = 64'h534A65DD74F873A6;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"655751\n");
+    	$fwrite(fp,"569159\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'hFE303FFFF7FFFFFF;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'hFAE03FFFF8000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'hC38FFFF7FFFFBFFE;
+    ans = 64'hC38FFFF7FFFFBFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"656365\n");
+    	$fwrite(fp,"569465\n");
     end
-    x = 64'h4010000220000000;
-    y = 64'h4F1000010000000E;
-    z = 64'h41D0000000200FFF;
-    ans = 64'h4F3000032000220E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h68000003FFFFC000;
+    ReadData2E = 64'hB807FFFFFFFFDFFE;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'hE0180005FFFF7FFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"656979\n");
+    	$fwrite(fp,"569771\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'h7FE0000000000000;
-    z = 64'hFFEFFFFFFFFFFFFF;
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"570077\n");
+    end
+    ReadData1E = 64'h41EFC450BF744BAF;
+    ReadData2E = 64'h327C8450FAFD9B42;
+    ReadData3E = 64'hC3E07FDFFFFFFFFF;
+    ans = 64'hC3E07FDFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"570383\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBFE0000000FBFFFF;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h3FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"570689\n");
+    end
+    ReadData1E = 64'h3CA0000000000017;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'h41FFFFFFE0000007;
+    ans = 64'h41FFFFFFE0000007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"570995\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h43D000FFF7FFFFFF;
+    ReadData3E = 64'h400125CBE8496822;
+    ans = 64'h40801225C3E84967;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"571301\n");
+    end
+    ReadData1E = 64'h40CFFFF3FFFFFFFE;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h4340000000001000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"571607\n");
+    end
+    ReadData1E = 64'h3E40010003FFFFFE;
+    ReadData2E = 64'hA40FFFFFFDFDFFFE;
+    ReadData3E = 64'h406000FFFFFFFBFF;
+    ans = 64'h406000FFFFFFFBFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"571913\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'h7FE0000000200001;
+    ans = 64'h7FE0000000200001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"572219\n");
+    end
+    ReadData1E = 64'h3C3FFFFFFFF8FFFF;
+    ReadData2E = 64'h43D2002000000000;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'h4022001FFFFC0FF8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"572525\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"572831\n");
+    end
+    ReadData1E = 64'hC7F0000000000000;
+    ReadData2E = 64'hBF9FFFDDFFFFFFFE;
+    ReadData3E = 64'h40DE38BD2F586C5E;
+    ans = 64'h479FFFDDFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"573137\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC0DFFFF7FEFFFFFF;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFE0000000007FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"573443\n");
+    end
+    ReadData1E = 64'h43C0007FFFBFFFFE;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hC789B6254B55142E;
+    ans = 64'hC789B6254B55142E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"573749\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3F7FFFFFFFFFDF7E;
+    ReadData3E = 64'hFFE2010000000000;
+    ans = 64'hFFE2010000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"574055\n");
+    end
+    ReadData1E = 64'h8810000000000000;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"574361\n");
+    end
+    ReadData1E = 64'hC3D00037FFFFFFFE;
+    ReadData2E = 64'h800021D5197DD041;
+    ReadData3E = 64'hFFEFFFFFFF800001;
+    ans = 64'hFFEFFFFFFF800001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"574667\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h402ABB9F5C413B98;
+    ans = 64'h402ABB9F5C413B98;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"574973\n");
+    end
+    ReadData1E = 64'hBFC000003FFFFFFF;
+    ReadData2E = 64'h3F503FFFFFEFFFFF;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"575279\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h4340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"575585\n");
+    end
+    ReadData1E = 64'hC01DFFFFEFFFFFFE;
+    ReadData2E = 64'h7FD07FFFFFFFFFFD;
+    ReadData3E = 64'hC3420FFFFFFFFFFF;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"575891\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hACD00000002FFFFE;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"576197\n");
+    end
+    ReadData1E = 64'hBE9FE20000000000;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'h381FFFFFFFFFF7BE;
+    ans = 64'hBE9FE20000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"576503\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC3F00001FEFFFFFF;
+    ReadData3E = 64'hC1D0FFFFFFDFFFFF;
+    ans = 64'hC1D10001FFE03FDF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"576809\n");
+    end
+    ReadData1E = 64'hC1FCE7CFD0B6C050;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'hC20CE7CFD096C04F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"577115\n");
+    end
+    ReadData1E = 64'h3F93E91553500BEA;
+    ReadData2E = 64'h41C0003FFFFFFDFE;
+    ReadData3E = 64'hBCC5DA60B1BB0238;
+    ans = 64'h4163E964F7A556AB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"577421\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h403FFFFFFFFFF807;
+    ans = 64'h403FFFFFFFFFF807;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"577727\n");
+    end
+    ReadData1E = 64'hC03BFFFFFDFFFFFF;
+    ReadData2E = 64'h40CF7FFFBFFFFFFE;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"578033\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"578339\n");
+    end
+    ReadData1E = 64'h4020000200000000;
+    ReadData2E = 64'hDFEFFEFFFFFFFDFF;
+    ReadData3E = 64'hC02003FFFFFFF7FE;
+    ans = 64'hE01FFF03FFDFFDFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"578645\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBCAFFFEFFFFFFFF0;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCA0000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"578951\n");
+    end
+    ReadData1E = 64'h7FD0800200000000;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'h801FF00000000000;
+    ans = 64'h7FE0800200000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"579257\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h001000000003FDFF;
+    ReadData3E = 64'hBF40007FFFFFC000;
+    ans = 64'hBF40007FFFFFC000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"579563\n");
+    end
+    ReadData1E = 64'h001014EBF46D200B;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hBFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"579869\n");
+    end
+    ReadData1E = 64'h3FDFFFFF00000020;
+    ReadData2E = 64'h2B63DAD3E09AF819;
+    ReadData3E = 64'hBFEB93086E12EDF7;
+    ans = 64'hBFEB93086E12EDF7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"580175\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FD00FDFFFFFFFFF;
+    ans = 64'h3FD00FE000000007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"580481\n");
+    end
+    ReadData1E = 64'h37F7FFFFFFF00000;
+    ReadData2E = 64'h001FFFFFE00000FE;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"580787\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"581093\n");
+    end
+    ReadData1E = 64'h801FF00000000000;
+    ReadData2E = 64'h6BC000009FFFFFFF;
+    ReadData3E = 64'hB7FEAFA4CE7A7EFB;
+    ans = 64'hB7FEAFA4CE7A7EFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"581399\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3F20080000000020;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h3BD0080000000020;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"581705\n");
+    end
+    ReadData1E = 64'h9E93DC7553D65AE9;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'hBFFFFFFEFFFFFEFF;
+    ans = 64'hBFFFFFFEFFFFFEFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"582011\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hFFFFFFF7F0000000;
+    ReadData3E = 64'h41CFFFFBFDFFFFFF;
+    ans = 64'hFFFFFFF7F0000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"582317\n");
+    end
+    ReadData1E = 64'hB6BFFFFFEFFFFFBF;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h3FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"582623\n");
+    end
+    ReadData1E = 64'h3C9FFFF7FFFF7FFF;
+    ReadData2E = 64'h41D437651490379B;
+    ReadData3E = 64'h3DD0000FFFFFFEFF;
+    ans = 64'h3E84396008B6A199;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"582929\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'h80008007FFFFFFFF;
+    ans = 64'h3CCFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"583235\n");
+    end
+    ReadData1E = 64'hBF783D0BB5184AF6;
+    ReadData2E = 64'hC06FFFFFFE00001E;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h4350000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"583541\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hBFFFFFFFFFFFFFFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"583847\n");
+    end
+    ReadData1E = 64'hC7FFFFFFFFFE7FFF;
+    ReadData2E = 64'hC010000000000FFF;
+    ReadData3E = 64'h43C00002FFFFFFFF;
+    ans = 64'h481FFFFFFFFE9FFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"584153\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hCA00001FFFFFEFFE;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'hC6B0001FFFFFEFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"584459\n");
+    end
+    ReadData1E = 64'h37E00007FFFFEFFE;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'h000B49FE64045BF1;
+    ans = 64'h38100007FFFFEFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"584765\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC16C0000001FFFFE;
+    ReadData3E = 64'h404FFFFBFFFFFFEF;
+    ans = 64'h404FFFFBFFFC7FEF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"585071\n");
+    end
+    ReadData1E = 64'hBC5FFFFFFF900000;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'hBFE1FFFFFFF90001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"585377\n");
+    end
+    ReadData1E = 64'h381FFFFFE01FFFFF;
+    ReadData2E = 64'hC34FFFFF007FFFFF;
+    ReadData3E = 64'hBFBBFFF7FFFFFFFF;
+    ans = 64'hBFBBFFF7FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"585683\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'h3F86422413F8A4BC;
+    ans = 64'h3FF02C844827F14A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"585989\n");
+    end
+    ReadData1E = 64'h3E6FFFFFFFFF0000;
+    ReadData2E = 64'h426118431D11305B;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'h40E117431D10A799;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"586295\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h4008000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"586601\n");
+    end
+    ReadData1E = 64'hD890000000000050;
+    ReadData2E = 64'hBF6FFFFBFFFFFEFF;
+    ReadData3E = 64'h47EFDFFFFFFFFFFD;
+    ans = 64'h580FFFFBFFFFFF9F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"586907\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h4000040000000000;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'h3CB0040000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"587213\n");
+    end
+    ReadData1E = 64'hFFF7FFFFFFFFFDFE;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'hBCA0007FF0000000;
+    ans = 64'hFFFFFFFFFFFFFDFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"587519\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FDFFFFFC0200000;
+    ReadData3E = 64'hBFCF31C105642E15;
+    ans = 64'hBFCF31C105642E13;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"587825\n");
+    end
+    ReadData1E = 64'hBD80000000FFFFF6;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'hFD70000000FFFFF6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"588131\n");
+    end
+    ReadData1E = 64'h3FEC96403447C6AD;
+    ReadData2E = 64'h0002000000000008;
+    ReadData3E = 64'hBFE00006FFFFFFFF;
+    ans = 64'hBFE00006FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"588437\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'h3F2FFFC1FFFFFFFF;
+    ans = 64'h7C90000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"588743\n");
+    end
+    ReadData1E = 64'hB4E1E8C057F4DF36;
+    ReadData2E = 64'h4039B6117BCEDD18;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"589049\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'h7C90000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"589355\n");
+    end
+    ReadData1E = 64'hC346816BDCBFF1FE;
+    ReadData2E = 64'h30C000000401FFFF;
+    ReadData3E = 64'hB7FFC3FFFFFFFFFF;
+    ans = 64'hB7FFC3FFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"589661\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC7FFFFFFC7FFFFFF;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"589967\n");
+    end
+    ReadData1E = 64'hBDA000010000000E;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h4E3FFFFFFFFFFBFC;
+    ans = 64'hFDA000010000000D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"590273\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FE0003BFFFFFFFF;
+    ReadData3E = 64'h3F1FFFFFFFFFF87F;
+    ans = 64'h3F20000000000440;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"590579\n");
+    end
+    ReadData1E = 64'hC2D00001FFFFF7FE;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"590885\n");
+    end
+    ReadData1E = 64'hCDE3FFFFFFF7FFFE;
+    ReadData2E = 64'hC00111153EA8B7A3;
+    ReadData3E = 64'hCC7FF7FFFEFFFFFF;
+    ans = 64'h4DF5555A6E525D00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"591191\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'hC3CE07315524DA3F;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"591497\n");
+    end
+    ReadData1E = 64'hBFC0000FFFFFE000;
+    ReadData2E = 64'h948FFFFF5FFFFFFF;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"591803\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"592109\n");
+    end
+    ReadData1E = 64'h88DAAC772E18D0E4;
+    ReadData2E = 64'h37EC230E5E47728C;
+    ReadData3E = 64'h43F1000000400000;
+    ans = 64'h43F1000000400000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"592415\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h402CF1C09BD3F810;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"592721\n");
+    end
+    ReadData1E = 64'hC37FFFFFFF00000F;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FBFFBFFFFFF7FFE;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"593027\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hDB1FFFFFFFF00080;
+    ReadData3E = 64'hBE52000000000040;
+    ans = 64'hD7CFFFFFFFF00080;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"593333\n");
+    end
+    ReadData1E = 64'h3560000000408000;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"593639\n");
+    end
+    ReadData1E = 64'hBF1FFE07FFFFFFFF;
+    ReadData2E = 64'hC1D0000004000FFE;
+    ReadData3E = 64'hB6CFFFFFFF040000;
+    ans = 64'h40FFFE0807FFA1F9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"593945\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h4BEFFFFFA0000000;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"594251\n");
+    end
+    ReadData1E = 64'hFFEEC7E41D48D9E4;
+    ReadData2E = 64'h403E000000000008;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"594557\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hBCAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"594863\n");
+    end
+    ReadData1E = 64'hC7FFFFFF00000004;
+    ReadData2E = 64'hBFDEFFEFFFFFFFFF;
+    ReadData3E = 64'hC1CFFFFE20000000;
+    ans = 64'h47EEFFEF08008003;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"595169\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC04FFFFFFFFBFFFE;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h434FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"595475\n");
+    end
+    ReadData1E = 64'hC1C0008007FFFFFF;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'hC6B4F3502E84A07B;
+    ans = 64'hC6B4F3502E84A07B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"595781\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FEBFFFFFFFFFBFF;
+    ReadData3E = 64'hB80A388A566C4856;
+    ans = 64'h3C9BFFFFFFFFFBFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"596087\n");
+    end
+    ReadData1E = 64'hDFEFC007FFFFFFFF;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h200FC007FFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"596393\n");
+    end
+    ReadData1E = 64'h3FB00000003DFFFF;
+    ReadData2E = 64'hC022000000000FFE;
+    ReadData3E = 64'h7FD04FFFFFFFFFFF;
+    ans = 64'h7FD04FFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"596699\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'h40000000000807FE;
+    ans = 64'h40000000000807FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"597005\n");
+    end
+    ReadData1E = 64'h00200000003FFFF7;
+    ReadData2E = 64'h03BB6A461A67FAB0;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hBFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"597311\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h3CA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"597617\n");
+    end
+    ReadData1E = 64'h5720000080001FFE;
+    ReadData2E = 64'h3FDFFFFFF00007FE;
+    ReadData3E = 64'hB80FF80003FFFFFF;
+    ans = 64'h57100000780023BD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"597923\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hCBBFFFFFFFFF07FF;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'hC86FFFFFFFFF07FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"598229\n");
+    end
+    ReadData1E = 64'h800FFFEFFFFFFFF6;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'hC3D20000003FFFFF;
+    ans = 64'hC3D20000003FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"598535\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC00000001FFFF800;
+    ReadData3E = 64'h5388000000000007;
+    ans = 64'h5388000000000007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"598841\n");
+    end
+    ReadData1E = 64'hFFDFDFFFFFFFFFFA;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h400FDFFFFFFFFFF9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"599147\n");
+    end
+    ReadData1E = 64'h38152BAF87CCD661;
+    ReadData2E = 64'hC80FFFFFFFFFE000;
+    ReadData3E = 64'h3816D0CC103DB538;
+    ans = 64'hC0352BAF87CCC135;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"599453\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h41C0040000000100;
+    ans = 64'h41C0040000000100;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"599759\n");
+    end
+    ReadData1E = 64'hC7FFFF8100000000;
+    ReadData2E = 64'hC060000000001FFC;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h486FFF8100003FF7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"600065\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h8010000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"600371\n");
+    end
+    ReadData1E = 64'hC00F0000000003FF;
+    ReadData2E = 64'h3FA07FFFFFFFFEFF;
+    ReadData3E = 64'h41FA412950FB1DC1;
+    ans = 64'h41FA412950F91E41;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"600677\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h47FC3AA54E792590;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h44AC3AA54E792590;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"600983\n");
+    end
+    ReadData1E = 64'hC7E000FFFFFFBFFF;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'h3FE744AF1E7842FB;
+    ans = 64'h449000FFFFFFBFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"601289\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC96FFFFFEFFFFFFF;
+    ReadData3E = 64'hC1FB8000D97D3B15;
+    ans = 64'hC61FFFFFEFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"601595\n");
+    end
+    ReadData1E = 64'hC34DDFFFFFFFFFFF;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"601901\n");
+    end
+    ReadData1E = 64'h4080000000000FEF;
+    ReadData2E = 64'hC1E3A3F229A0185E;
+    ReadData3E = 64'hC3CFFFFFFFFFFFF5;
+    ans = 64'hC3D000004E8FC8A1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"602207\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'hC801FFFFFFFFFF7F;
+    ans = 64'hC801FFFFFFFFFF7F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"602513\n");
+    end
+    ReadData1E = 64'hBFCFFBFFFFFFF000;
+    ReadData2E = 64'hBFC00FFFFBFFFFFF;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hBFCBFC8080FFE204;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"602819\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'hB95FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"603125\n");
+    end
+    ReadData1E = 64'h40DFFFFFFFFFBDFF;
+    ReadData2E = 64'hC1E000000047FFFE;
+    ReadData3E = 64'hC000000000000202;
+    ans = 64'hC2D000000047DF7D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"603431\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h40D00000000003FF;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hC00FFFFFFFFFEFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"603737\n");
+    end
+    ReadData1E = 64'hC0310003FFFFFFFF;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'hBB8FFC000000007F;
+    ans = 64'h40110003FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"604043\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h43D0000004000003;
+    ReadData3E = 64'hBDF0010000200000;
+    ans = 64'h4080000003FFF802;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"604349\n");
+    end
+    ReadData1E = 64'h4B40000000000408;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"604655\n");
+    end
+    ReadData1E = 64'h3800002007FFFFFE;
+    ReadData2E = 64'h41EFFF7F7FFFFFFF;
+    ReadData3E = 64'h403000000000007E;
+    ans = 64'h403000000000007E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"604961\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'h402FFFB7FFFFFFFF;
+    ans = 64'h402FFFB7FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"605267\n");
+    end
+    ReadData1E = 64'h3FCF03FFFFFFFFFF;
+    ReadData2E = 64'hBFEFFFFFDFFBFFFE;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'hBFCF03FFE0F81F75;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"605573\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"605879\n");
+    end
+    ReadData1E = 64'hC01000000000FFFE;
+    ReadData2E = 64'h380FFFFFF7FFFFFE;
+    ReadData3E = 64'h41F00FFFFFFFFFFE;
+    ans = 64'h41F00FFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"606185\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3AEFDFFBFFFFFFFF;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"606491\n");
+    end
+    ReadData1E = 64'hBFFFFFFFFDFEFFFF;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'hC2A0000008000200;
+    ans = 64'hC2A0000008000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"606797\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h41EFFFFE000003FF;
+    ReadData3E = 64'h48A0080020000000;
+    ans = 64'h48A0080020000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"607103\n");
+    end
+    ReadData1E = 64'h40700000000FFF7F;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"607409\n");
+    end
+    ReadData1E = 64'hC00FFFC0007FFFFF;
+    ReadData2E = 64'hC3F0040000000008;
+    ReadData3E = 64'hB659C33D767BD014;
+    ans = 64'h441003DFF8401007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"607715\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'hC1F2000000000FFE;
+    ans = 64'hC1F2000000000FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"608021\n");
+    end
+    ReadData1E = 64'h402008FFFFFFFFFF;
+    ReadData2E = 64'h3242C59B272E2C9F;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'h3272D02A4E743697;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"608327\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"608633\n");
+    end
+    ReadData1E = 64'h800FFFE00000FFFE;
+    ReadData2E = 64'h3FA0001001FFFFFF;
+    ReadData3E = 64'h43C003FFFFFFFFEF;
+    ans = 64'h43C003FFFFFFFFEF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"608939\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h002000000801FFFF;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"609245\n");
+    end
+    ReadData1E = 64'hBFA5D7C957A5866C;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h055FFFFFFFFFEFF7;
+    ans = 64'h3FA5D7C957A5866B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"609551\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FBFFC0001FFFFFF;
+    ReadData3E = 64'h47ECC30A16FAE247;
+    ans = 64'h47ECC30A16FAE247;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"609857\n");
+    end
+    ReadData1E = 64'h4031FFFFFFFFFFFD;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC350000000000004;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"610163\n");
+    end
+    ReadData1E = 64'h3FFE33B9FA55737D;
+    ReadData2E = 64'h3F40800000002000;
+    ReadData3E = 64'h88800007FDFFFFFF;
+    ans = 64'h3F4F2557CA285B80;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"610469\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'hC905F36EE24991F7;
+    ans = 64'hC905F36EE24991F7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"610775\n");
+    end
+    ReadData1E = 64'hC1D827F19B2DAC3D;
+    ReadData2E = 64'h3F6F6A8CE25E0151;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'hC157B720B8485DBA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"611081\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"611387\n");
+    end
+    ReadData1E = 64'h43F213A13D95B43D;
+    ReadData2E = 64'hC1DFFFFFF0020000;
+    ReadData3E = 64'h3EEFFF0000000040;
+    ans = 64'hC5E213A1348D04D8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"611693\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hFFF0000000010001;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'hFFF8000000010001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"611999\n");
+    end
+    ReadData1E = 64'h37E3FFFFFFFFFFFD;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FEFDFFFFBFFFFFE;
+    ans = 64'h3FEFDFFFFBFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"612305\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h55BFFFFFFF87FFFF;
+    ReadData3E = 64'hC18000000000FBFE;
+    ans = 64'h526FFFFFFF87FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"612611\n");
+    end
+    ReadData1E = 64'h434DFEFFFFFFFFFE;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'hC35DFEFFFFFFFFFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"612917\n");
+    end
+    ReadData1E = 64'h7FE80001FFFFFFFF;
+    ReadData2E = 64'hD48FFFFFFFFFBFBF;
+    ReadData3E = 64'h001FFFF001000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"613223\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'h5CADFFFFFFFEFFFF;
+    ans = 64'h5CADFFFFFFFEFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"613529\n");
+    end
+    ReadData1E = 64'hB79C1C39DCEBED2B;
+    ReadData2E = 64'h41E053AEA45FFB4B;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'hB98CAF3F1CD529BE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"613835\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"614141\n");
+    end
+    ReadData1E = 64'hB35FFEFFFFFFFFEE;
+    ReadData2E = 64'h43CFFFFFFFF80000;
+    ReadData3E = 64'h41EFFF7FFBFFFFFF;
+    ans = 64'h41EFFF7FFBFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"614447\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBFC0002000000007;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"614753\n");
+    end
+    ReadData1E = 64'hC3D242D889644CD5;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h408FFFFFFFFFFFFF;
+    ans = 64'h43F242D889644CD5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"615059\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC02000017FFFFFFE;
+    ReadData3E = 64'h4170000FFFFFFFC0;
+    ans = 64'h4170000FFFFFFFC0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"615365\n");
+    end
+    ReadData1E = 64'h7FE0FFFFF8000000;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"615671\n");
+    end
+    ReadData1E = 64'h428821EC16CB5777;
+    ReadData2E = 64'hA0DFFF7FFFFFFBFE;
+    ReadData3E = 64'h402E008000000000;
+    ans = 64'h402E008000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"615977\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'h39F00000000201FF;
+    ans = 64'hBCBFFFFFFFFFFEFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"616283\n");
+    end
+    ReadData1E = 64'hBFFFFDFFFFFFFBFF;
+    ReadData2E = 64'hB06800000000000F;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"616589\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h401FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"616895\n");
+    end
+    ReadData1E = 64'h402BFFFFFFFFFFDF;
+    ReadData2E = 64'h3CA000010003FFFE;
+    ReadData3E = 64'h3F8FFFFF03FFFFFF;
+    ans = 64'h3F8FFFFF0400037F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"617201\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC060000300000000;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'hBD0F800600000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"617507\n");
+    end
+    ReadData1E = 64'hC03FFFFFFFF00000;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'hF9FFFBE000000000;
+    ans = 64'hF9FFFBE000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"617813\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBFFFFFFFFFEFFF80;
+    ReadData3E = 64'h3FEFFC1FFFFFFFFF;
+    ans = 64'h3FEFFC1FFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"618119\n");
+    end
+    ReadData1E = 64'h4F98000000000010;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'hCFC800000000000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"618425\n");
+    end
+    ReadData1E = 64'hC05FFFFFFE000001;
+    ReadData2E = 64'h4CDFFDFFFFFFC000;
+    ReadData3E = 64'h38000000000001FF;
+    ans = 64'hCD4FFDFFFDFFE001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"618731\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'hB7E07FFFEFFFFFFF;
+    ans = 64'hBCCFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"619037\n");
+    end
+    ReadData1E = 64'h41D05FFFFFFFFFFF;
+    ReadData2E = 64'hB7E0400001FFFFFF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"619343\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"619649\n");
+    end
+    ReadData1E = 64'h80400000003FFEFE;
+    ReadData2E = 64'hA979AC1965929EB1;
+    ReadData3E = 64'hAD5FFF8000040000;
+    ans = 64'hAD5FFF8000040000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"619955\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h802FF8007FFFFFFF;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hBCA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"620261\n");
+    end
+    ReadData1E = 64'hAFBFFFF77FFFFFFF;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'h3D700100000000FF;
+    ans = 64'h3D700100000000FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"620567\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h84E6EACDC3A87267;
+    ReadData3E = 64'hC1C400FFFFFFFFFF;
+    ans = 64'hC1C400FFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"620873\n");
+    end
+    ReadData1E = 64'hC3CFF800000000FE;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'h471FF80000000100;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"621179\n");
+    end
+    ReadData1E = 64'hC13FC000007FFFFF;
+    ReadData2E = 64'hFFE2000FFFFFFFFF;
+    ReadData3E = 64'h002A87E3D45EB225;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"621485\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'h37FFFE00007FFFFF;
+    ans = 64'hBFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"621791\n");
+    end
+    ReadData1E = 64'hC7E0000000000FFF;
+    ReadData2E = 64'h047FFFF7FF7FFFFE;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"622097\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'h3CD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"622403\n");
+    end
+    ReadData1E = 64'h40D02007FFFFFFFF;
+    ReadData2E = 64'hC2D0000010000000;
+    ReadData3E = 64'h3F8FF800000000FF;
+    ans = 64'hC3B02008102007FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"622709\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h002007FFF7FFFFFE;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h0010000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"623015\n");
+    end
+    ReadData1E = 64'h079F657DBB247EA0;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'hC25FFFFFBFFFFFDF;
+    ans = 64'hC78F657DBB247EA0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"623321\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hBEEFFFFFEFFFFEFE;
+    ReadData3E = 64'hC3C9C7B1F71A5415;
+    ans = 64'hC3C9C7B1F71A5415;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"623627\n");
+    end
+    ReadData1E = 64'h4030003FFFFFE000;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"623933\n");
+    end
+    ReadData1E = 64'h381FFDFFFFFFFFF7;
+    ReadData2E = 64'h8013948FB121E71F;
+    ReadData3E = 64'h411CAEB412B45C02;
+    ans = 64'h411CAEB412B45C02;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"624239\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'h403007E000000000;
+    ans = 64'hFC90000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"624545\n");
+    end
+    ReadData1E = 64'hBFEEFFFFFFFEFFFF;
+    ReadData2E = 64'h69A22FBA6F273FE0;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'hE9A19E3C9BAD7463;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"624851\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hFC9FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"625157\n");
+    end
+    ReadData1E = 64'hBFF0400002000000;
+    ReadData2E = 64'hBB10000000020007;
+    ReadData3E = 64'hC1D3FFFF7FFFFFFF;
+    ans = 64'hC1D3FFFF7FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"625463\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h37EFFFEFFFFDFFFF;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'h349FFFEFFFFDFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"625769\n");
+    end
+    ReadData1E = 64'hBE01000000100000;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFD79D33FB7309A1;
+    ans = 64'h7E010000000FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"626075\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h3FF0008000007FFE;
+    ReadData3E = 64'hC00D7B1E10F4ADFA;
+    ans = 64'hC00D7B1E10F4ADFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"626381\n");
+    end
+    ReadData1E = 64'h434000000011FFFF;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"626687\n");
+    end
+    ReadData1E = 64'h3F26F62E6A714B72;
+    ReadData2E = 64'hBFC0803FFFFFFFFF;
+    ReadData3E = 64'h7FD72CEED46BAEAA;
+    ans = 64'h7FD72CEED46BAEAA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"626993\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'hDBAEFFFFF0000000;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"627299\n");
+    end
+    ReadData1E = 64'h8332000010000000;
+    ReadData2E = 64'h4010001FFFF00000;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"627605\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"627911\n");
+    end
+    ReadData1E = 64'h510000200FFFFFFF;
+    ReadData2E = 64'hC1E000003FFFFFF7;
+    ReadData3E = 64'hB80FFFFFFE000002;
+    ans = 64'hD2F0002050008036;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"628217\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h480FFFFDFFFE0000;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"628523\n");
+    end
+    ReadData1E = 64'h380FFFFDE0000000;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC01FBFFFFFFF7FFF;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"628829\n");
+    end
+    ReadData1E = 64'h3CA0000000000000;
+    ReadData2E = 64'h00201FFFFFFFFFFC;
+    ReadData3E = 64'h47F17FFFFFFFFFFE;
+    ans = 64'h47F17FFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"629135\n");
+    end
+    ReadData1E = 64'h436F040000000000;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"629441\n");
+    end
+    ReadData1E = 64'h421FFFEFFBFFFFFF;
+    ReadData2E = 64'h8013FFFFFFFEFFFF;
+    ReadData3E = 64'h207100007FFFFFFF;
+    ans = 64'h207100007FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"629747\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'h43FFFFFFFFFC003E;
+    ans = 64'h43FFFFFFFFFC003E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"630053\n");
+    end
+    ReadData1E = 64'hFFEFF7FFFF800000;
+    ReadData2E = 64'h3FDE5AB5F7C3CD81;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'hFFDE531F49CC71B6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"630359\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hBFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"630665\n");
+    end
+    ReadData1E = 64'h400FFE000000003F;
+    ReadData2E = 64'hBFDDE4D607B230AB;
+    ReadData3E = 64'hC0235239DEB3F143;
+    ans = 64'hC0270E98D5FE27FB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"630971\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h38F581177512E12D;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"631277\n");
+    end
+    ReadData1E = 64'hC03FFFFF7FFFFC00;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'hBE40003FFFFFFFFB;
+    ans = 64'hBE40003FFFFFFFFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"631583\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h43D35E20BE8A9BED;
+    ReadData3E = 64'h43DFF80000007FFF;
+    ans = 64'h43DFF80000008000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"631889\n");
+    end
+    ReadData1E = 64'h026BEB43DDA12286;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hBCAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"632195\n");
+    end
+    ReadData1E = 64'hD52FFDFFFFBFFFFF;
+    ReadData2E = 64'hC3F3CE1F9D970A2F;
+    ReadData3E = 64'h43FF8007FFFFFFFF;
+    ans = 64'h5933CCE2BB75947F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"632501\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'h47E000007FF7FFFF;
+    ans = 64'h47E000007FF7FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"632807\n");
+    end
+    ReadData1E = 64'hBDDE688351B4049B;
+    ReadData2E = 64'h7FEFBFE000000000;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hFDDE2B93E28D4ADE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"633113\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"633419\n");
+    end
+    ReadData1E = 64'h3FDFC00000001FFE;
+    ReadData2E = 64'hC1324744F5C38C98;
+    ReadData3E = 64'hC0000000FFF7FFFF;
+    ans = 64'hC12222BA6BD857C3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"633725\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBF0FE29A47D0D921;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"634031\n");
+    end
+    ReadData1E = 64'hF0BFFFBFFFBFFFFF;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'h3E06C8F7F58C7A61;
+    ans = 64'h3E06C8F7F58C7A61;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"634337\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3ED8926415D98F05;
+    ReadData3E = 64'h3FD100000007FFFE;
+    ans = 64'h3FD100000007FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"634643\n");
+    end
+    ReadData1E = 64'hBFF0000000400001;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h8000000000800002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"634949\n");
+    end
+    ReadData1E = 64'h480FFFFBFFFFFFF7;
+    ReadData2E = 64'h480FFFFFFFFFFFFE;
+    ReadData3E = 64'h381A32D57211B378;
+    ans = 64'h502FFFFBFFFFFFF5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"635255\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'h3D2692C6C6F6F414;
+    ans = 64'h3D2692C6C6F6F414;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"635561\n");
+    end
+    ReadData1E = 64'h7FFFFFBFFFFFFFFE;
+    ReadData2E = 64'h37FFDFFFFF800000;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h7FFFFFBFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"635867\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hBCAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"636173\n");
+    end
+    ReadData1E = 64'hBA50000FFFFFDFFE;
+    ReadData2E = 64'h37FFFFEFFDFFFFFE;
+    ReadData3E = 64'h3FB4000000000007;
+    ans = 64'h3FB4000000000007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"636479\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hB06D5172C00F57DE;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h434FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"636785\n");
+    end
+    ReadData1E = 64'hFFFFFFF0003FFFFF;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'hFFEFFBFFFF000000;
+    ans = 64'hFFFFFFF0003FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"637091\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFF0100000003FFF;
+    ReadData3E = 64'h402FFFEFFF7FFFFF;
+    ans = 64'h402FFFEFFF7FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"637397\n");
+    end
+    ReadData1E = 64'hC7F93F6288E6DA64;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'hC4B93F6288E6DA63;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"637703\n");
+    end
+    ReadData1E = 64'hC3FFFFFFFFFFFCFF;
+    ReadData2E = 64'hBFDFF3DD4FECC275;
+    ReadData3E = 64'hFFDFF801FFFFFFFF;
+    ans = 64'hFFDFF801FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"638009\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'h43DFFC1FFFFFFFFF;
+    ans = 64'h43DFFC1FFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"638315\n");
+    end
+    ReadData1E = 64'hC1CFFFFFFBFF7FFF;
+    ReadData2E = 64'h4060000207FFFFFE;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hC240000206003FBC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"638621\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h3C80000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"638927\n");
+    end
+    ReadData1E = 64'hFFD00001FFF00000;
+    ReadData2E = 64'hC340003FFFEFFFFF;
+    ReadData3E = 64'hBFEFFBFFFFFFF7FE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"639233\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h7F60000000000DFF;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'h7C10000000000E00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"639539\n");
+    end
+    ReadData1E = 64'h41DDFFFFF7FFFFFE;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'hBD8FFFFFBFFFFFFC;
+    ans = 64'h41BDFFFFF8000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"639845\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h404BFFFFFFFFFF7F;
+    ReadData3E = 64'hBE20050000000000;
+    ans = 64'hBE2004FC80000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"640151\n");
+    end
+    ReadData1E = 64'hBFD00000080FFFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'hBFC00000080FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"640457\n");
+    end
+    ReadData1E = 64'h3DF0000200000200;
+    ReadData2E = 64'h4CD000004003FFFF;
+    ReadData3E = 64'hC1C0008000FFFFFE;
+    ans = 64'h4AD0000240040A00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"640763\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'h014FFFFF7FFFBFFF;
+    ans = 64'h3C90000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"641069\n");
+    end
+    ReadData1E = 64'h406FFFFFFF0000FF;
+    ReadData2E = 64'h41D020000000007F;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h42501FFFFF7F20FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"641375\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h3C90000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"641681\n");
+    end
+    ReadData1E = 64'h3BA211127EC45600;
+    ReadData2E = 64'h358FFFFF80004000;
+    ReadData3E = 64'h3FCFFFFFFFFFDFF0;
+    ans = 64'h3FCFFFFFFFFFDFF0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"641987\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFB2000000000003;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"642293\n");
+    end
+    ReadData1E = 64'hC3CFFBFFDFFFFFFF;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'hEE6C9467FCA47D87;
+    ans = 64'hEE6C9467FCA47D87;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"642599\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h5EB01FF7FFFFFFFF;
+    ReadData3E = 64'h37E0037FFFFFFFFE;
+    ans = 64'h5B601FF800000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"642905\n");
+    end
+    ReadData1E = 64'h47FC4B89B376A36D;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"643211\n");
+    end
+    ReadData1E = 64'h3FFBFBFFFFFFFFFE;
+    ReadData2E = 64'hC00F00000FFFFFFF;
+    ReadData3E = 64'hB819596CB6C487DA;
+    ans = 64'hC01B1C200DFDFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"643517\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FF0000000003EFF;
+    ans = 64'h3FF0000000003F00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"643823\n");
+    end
+    ReadData1E = 64'hC05F7FFFEFFFFFFF;
+    ReadData2E = 64'h8000100000000003;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'hBFD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"644129\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'h3CA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"644435\n");
+    end
+    ReadData1E = 64'hB7FFFFF800000008;
+    ReadData2E = 64'h3FFF6C3812CF83F7;
+    ReadData3E = 64'h811FFFFFFFFF7C00;
+    ans = 64'hB80F6C3037C17F4B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"644741\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFCFC00000000010;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"645047\n");
+    end
+    ReadData1E = 64'hC03FFFFF000FFFFE;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'hB81FBFFFFFFFF000;
+    ans = 64'hC03FFFFF000FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"645353\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBF3FFFFF00000004;
+    ReadData3E = 64'h401000007DFFFFFF;
+    ans = 64'h401000007DFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"645659\n");
+    end
+    ReadData1E = 64'hC1F00000000001FF;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
     ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"645965\n");
+    end
+    ReadData1E = 64'h40154B404B0501A2;
+    ReadData2E = 64'h380000000003FFFE;
+    ReadData3E = 64'hBFEFFEFFFDFFFFFF;
+    ans = 64'hBFEFFEFFFDFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"646271\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'hCDC3FFEFFFFFFFFF;
+    ans = 64'hCDC3FFEFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"646577\n");
+    end
+    ReadData1E = 64'h403000083FFFFFFE;
+    ReadData2E = 64'h43FFFFEFFEFFFFFF;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'h444000003F7BDFBC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"646883\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"647189\n");
+    end
+    ReadData1E = 64'h41E0000020FFFFFE;
+    ReadData2E = 64'hBD4FFFFFFFDFEFFF;
+    ReadData3E = 64'h332FB80000000000;
+    ans = 64'hBF40000020EFF7FD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"647495\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h43D0000103FFFFFF;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h4080100104000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"647801\n");
+    end
+    ReadData1E = 64'h42A01FFFFFFFFFFF;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h43E00FFF7FFFFFFF;
+    ans = 64'h43E0100183FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"648107\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC3C7CB413AF78371;
+    ReadData3E = 64'hC02000004001FFFE;
+    ans = 64'hC0784B413CF79372;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"648413\n");
+    end
+    ReadData1E = 64'hC1E0000001FBFFFF;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"648719\n");
+    end
+    ReadData1E = 64'hC00FFC0000001FFF;
+    ReadData2E = 64'h3F3FFC000007FFFE;
+    ReadData3E = 64'h801352A02834F823;
+    ans = 64'hBF5FF80080081EF9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"649025\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'h402DFA51AAFBA1CF;
+    ans = 64'h402DFA51AAFBA1CF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"649331\n");
+    end
+    ReadData1E = 64'h402D6AD405E9D0E2;
+    ReadData2E = 64'h4006699A3858A969;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h40449A8611ACF7D4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"649637\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"649943\n");
+    end
+    ReadData1E = 64'h801FFFF77FFFFFFF;
+    ReadData2E = 64'hC01040000000000F;
+    ReadData3E = 64'h2C4000FFFDFFFFFF;
+    ans = 64'h2C4000FFFDFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"650249\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h38003FFFF7FFFFFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hBFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"650555\n");
+    end
+    ReadData1E = 64'h3B10000100000007;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'h47F0000200000003;
+    ans = 64'h47F0000200000003;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"650861\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC679CC0F7B01DBF2;
+    ReadData3E = 64'hC7F000000FFFDFFE;
+    ans = 64'hC7F000000FFFDFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"651167\n");
+    end
+    ReadData1E = 64'hBCA403A0FE29F2F7;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"651473\n");
+    end
+    ReadData1E = 64'hC7FFC603B5F552D5;
+    ReadData2E = 64'hC01000000800001E;
+    ReadData3E = 64'h40E00007FFFEFFFF;
+    ans = 64'h481FC603C5D854EC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"651779\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'hC0300000000077FE;
+    ans = 64'hC0300000000077FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"652085\n");
+    end
+    ReadData1E = 64'h3CA7F3ED2FDBC84E;
+    ReadData2E = 64'hC806121D06A51CCD;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'hC4C08542005A4C7C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"652391\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"652697\n");
+    end
+    ReadData1E = 64'h3FAFFFFFFFFFFBBE;
+    ReadData2E = 64'h428FFF800001FFFF;
+    ReadData3E = 64'h43D000080000001F;
+    ans = 64'h43D000080FFFC01F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"653003\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h7FD4BB6592591753;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h7C84BB6592591754;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"653309\n");
+    end
+    ReadData1E = 64'h41EFFFFF7FFFFFDF;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'hC3CFFFFFFBFFEFFF;
+    ans = 64'hC3CFFFFFF7FFF00F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"653615\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h4160000200000020;
+    ReadData3E = 64'h3FD0000001FFFFFF;
+    ans = 64'h3FD000000300001F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"653921\n");
+    end
+    ReadData1E = 64'hBAEC7B3DC3F4513A;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h401FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"654227\n");
+    end
+    ReadData1E = 64'hC7DFFFFFFF7FBFFE;
+    ReadData2E = 64'h001FFBFFEFFFFFFF;
+    ReadData3E = 64'hBFF5AE5B27D1523E;
+    ans = 64'hBFF5AE5B27D1523E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"654533\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'hC330001000000FFF;
+    ans = 64'hC330001000000FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"654839\n");
+    end
+    ReadData1E = 64'h41D0000000007FEF;
+    ReadData2E = 64'hA5E040000000FFFE;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'hA7C04000000181ED;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"655145\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"655451\n");
+    end
+    ReadData1E = 64'h7FE000007F7FFFFE;
+    ReadData2E = 64'hBFFFFFFFFFC00400;
+    ReadData3E = 64'hBFCFFFFFFFFFFCFF;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"655757\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC3C000800000007E;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hC07004800000007F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"656063\n");
+    end
+    ReadData1E = 64'hC5B00000000FFFFD;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h47DDFFFFFFFFDFFF;
+    ans = 64'hC90FFFFC401FFFF9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"656369\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC7E1FFFFFFFFFFBF;
+    ReadData3E = 64'h7FEFFFFBFFFFFFF0;
+    ans = 64'h7FEFFFFBFFFFFFF0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"656675\n");
+    end
+    ReadData1E = 64'hC0CFFEFFFC000000;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hC42FFEFFFBFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"656981\n");
+    end
+    ReadData1E = 64'h40054BEC3E7261FE;
+    ReadData2E = 64'h4433FF2ED149427C;
+    ReadData3E = 64'h41E7FFFFFFFDFFFE;
+    ans = 64'h444A9DD0E023E7B4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"657287\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'h66DFFEFFBFFFFFFE;
+    ans = 64'h66DFFEFFBFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
@@ -50376,7189 +83839,11971 @@ initial
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
     	$fwrite(fp,"657593\n");
     end
-    x = 64'h37E6C14F3ECC26DC;
-    y = 64'h000FFFFFFFF0007E;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFEF7FFF7FFFFFFE;
+    ReadData2E = 64'h37E0000000FFFDFE;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"658207\n");
+    	$fwrite(fp,"657899\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h4013F2A6D8BFBBDB;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h7C90000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"658205\n");
+    end
+    ReadData1E = 64'hBF6FFFFFBFFFFC00;
+    ReadData2E = 64'hC1CFFFFFDFFFFFFF;
+    ReadData3E = 64'h401000000FFFFFDE;
+    ans = 64'h41500000CFFFFF1F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"658511\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3ED50A68C526C672;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'h3CB00002A14D18A4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"658817\n");
+    end
+    ReadData1E = 64'hBFDFF7FFFFFFFFBF;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'hBFCEC55F3EC9F46F;
+    ans = 64'hFFCFF7FFFFFFFFC1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"659123\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC1272DC69C306421;
+    ReadData3E = 64'hB80FFBFFFFFFFFEE;
+    ans = 64'hBDD72DC69C306422;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"659429\n");
+    end
+    ReadData1E = 64'hBFD078B42033B059;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'hFFD078B42033B058;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"659735\n");
+    end
+    ReadData1E = 64'h43C8703ECCDE6D0D;
+    ReadData2E = 64'h3DAFFFFFFFFF7FDF;
+    ReadData3E = 64'h8881DECC22925CB8;
+    ans = 64'h4188703ECCDE0B33;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"660041\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h5760003FFF000000;
     ans = 64'h7CA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"658821\n");
+    	$fwrite(fp,"660347\n");
     end
-    x = 64'h47F66E124896F602;
-    y = 64'h43FFFCFFFFFFFFFF;
-    z = 64'hC02C17F8E33324F9;
-    ans = 64'h4C066BF7F6E027DA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3F04000000FFFFFF;
+    ReadData2E = 64'h7FD7FFFFFFFFFFEF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"659435\n");
+    	$fwrite(fp,"660653\n");
     end
-    x = 64'hC696F52476AFBCC8;
-    y = 64'h7FF0000000000000;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'h7CA0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"660049\n");
+    	$fwrite(fp,"660959\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'hC1CFFE0000400000;
-    z = 64'h483FFFC00007FFFF;
-    ans = 64'h483FFFC00007FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h41CFFC000000003E;
+    ReadData2E = 64'hDFA002000007FFFF;
+    ReadData3E = 64'h43EFFFFFFFFFDF80;
+    ans = 64'hE17FFFFF800FFE3C;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"660663\n");
+    	$fwrite(fp,"661265\n");
     end
-    x = 64'hC7E00002000007FF;
-    y = 64'h7FF0000000000001;
-    z = 64'hC7EFE000003FFFFF;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3FF002000000001E;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'h3CA002000000001F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"661571\n");
+    end
+    ReadData1E = 64'h78303FFFFFFFFFDE;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h405000000000403E;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"661877\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC1DFFFFFFFFFFFDE;
+    ReadData3E = 64'h800BFFFFFFFFFFFF;
+    ans = 64'hBE8FFFFFFFFFFFE0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"662183\n");
+    end
+    ReadData1E = 64'hC340000000003EFF;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'hBFF0000000000001;
     ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"661277\n");
+    	$fwrite(fp,"662489\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'hCB5FFFFDF7FFFFFE;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'hC80FFFFDF8000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC3E0000040000FFE;
+    ReadData2E = 64'h4270000000003FFE;
+    ReadData3E = 64'h3120BFFFFFFFFFFE;
+    ans = 64'hC660000040004FFC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"661891\n");
+    	$fwrite(fp,"662795\n");
     end
-    x = 64'hC1E00800000007FF;
-    y = 64'h000FFFFFFFF00020;
-    z = 64'hBE8FFFFFFFFFFFDA;
-    ans = 64'hBE8FFFFFFFFFFFDA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"662505\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"663119\n");
-    end
-    x = 64'h41E000FFFE000000;
-    y = 64'hBFF0000100000100;
-    z = 64'hBFE0000000000000;
-    ans = 64'hC1E00100FE2000E0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"663733\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h8000000000000001;
-    z = 64'h4030A513CDCFDE22;
-    ans = 64'h4030A513CDCFDE22;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"664347\n");
-    end
-    x = 64'hBF90A893B7D37E1B;
-    y = 64'hC00460035561ED96;
-    z = 64'hE6CEFFFFFFFFFFFE;
-    ans = 64'hE6CEFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"664961\n");
-    end
-    x = 64'h3BEFE000FFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h0000000000000000;
-    ans = 64'h8000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"665575\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hC1F6C8E803D2458C;
-    z = 64'h43F00000000080FE;
-    ans = 64'h43F00000000080FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"666189\n");
-    end
-    x = 64'h3F6FFFF00FFFFFFF;
-    y = 64'h8010000000000000;
-    z = 64'h3F9000000000000F;
-    ans = 64'h3F9000000000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"666803\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hC120000000200040;
-    z = 64'h4010000000000000;
-    ans = 64'h400FFFFFFFFE0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"667417\n");
-    end
-    x = 64'h3FC00010000000FE;
-    y = 64'hBB800000000100FF;
-    z = 64'hC80FC00001FFFFFF;
-    ans = 64'hC80FC00001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"668031\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"668645\n");
-    end
-    x = 64'hC7EF2E0B46A61E7E;
-    y = 64'hBFFFFF80000007FF;
-    z = 64'hBFD0000000000001;
-    ans = 64'h47FF2D8E8E790BB0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"669259\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hBCA0000000000000;
-    z = 64'h3801FFFFFFDFFFFE;
-    ans = 64'hB94FFFFEE0000004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"669873\n");
-    end
-    x = 64'hFFD00000000001FF;
-    y = 64'h352FFF7C00000000;
-    z = 64'hBC7FFDF000000000;
-    ans = 64'hF50FFF7C000003FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"670487\n");
-    end
-    x = 64'h37E04000000003FE;
-    y = 64'hBCA0000000000001;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"671101\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hB80D3E094BC16B46;
-    z = 64'hC7FC72513751EFEA;
-    ans = 64'hC7FC72513751EFEA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"671715\n");
-    end
-    x = 64'h3FA0001400000000;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hBF23FBFFFFFFFFFE;
-    ans = 64'hBF23FC00000000FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"672329\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hB8010000007FFFFF;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"672943\n");
-    end
-    x = 64'h7FE00000FFFFFFEE;
-    y = 64'hC00FFFFFFFFFFF76;
-    z = 64'h47E80CB0EEBCEF16;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"673557\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hBFD0000000000001;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"674171\n");
-    end
-    x = 64'hC520008000020000;
-    y = 64'h3FBFFFFFFDFFFFFC;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hC4F0007FFF01F7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"674785\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h38113D51639121A9;
-    ans = 64'hBC90000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"675399\n");
-    end
-    x = 64'hFFFFFFFBEFFFFFFE;
-    y = 64'hC3FF564D15AB56DC;
-    z = 64'h56BF000000000003;
-    ans = 64'hFFFFFFFBEFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"676013\n");
-    end
-    x = 64'h4035C1F65B378519;
-    y = 64'hBFE0000000000000;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"676627\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hBA2FDFFFFFFDFFFF;
-    z = 64'h402FFFFFFFFFE1FF;
-    ans = 64'h402FFFFFFFFFE1FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"677241\n");
-    end
-    x = 64'h401C000001FFFFFF;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hC34C792259BDA2BF;
-    ans = 64'hC34C792259BDA2C3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"677855\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hFFF0000000006000;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'hFFF8000000006000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"678469\n");
-    end
-    x = 64'h47FFFFF80000007F;
-    y = 64'h3A1BDFDA2C46A1D6;
-    z = 64'h46EFFFFFFFFFE07F;
-    ans = 64'h46EFFFFFFFFFE07F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"679083\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hBFF0000000000000;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"679697\n");
-    end
-    x = 64'h44F0000000000DFF;
-    y = 64'h000000007FBFFFFE;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h03BFEFFFFF801BF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"680311\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h3FF0007FFFFFFC00;
-    ans = 64'h3FF0007FFFFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"680925\n");
-    end
-    x = 64'hC000000000000000;
-    y = 64'hC010000100001FFE;
-    z = 64'h405157A7B0E2BCA9;
-    ans = 64'h405357A7D0E2C0A9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"681539\n");
-    end
-    x = 64'h44D400000007FFFF;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC4E400000807FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"682153\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hFFF0000000001FFD;
-    z = 64'hC1E000080000003F;
-    ans = 64'hFFF8000000001FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"682767\n");
-    end
-    x = 64'h4BD00003FFDFFFFE;
-    y = 64'hC000000000000001;
-    z = 64'hD4CFFFFFFFFFFC02;
-    ans = 64'hD4CFFFFFFFFFFC02;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"683381\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hC19000002000007F;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h3FEFFFFFFBFFFFF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"683995\n");
-    end
-    x = 64'hBCAFFEFEFFFFFFFE;
-    y = 64'h41DFFFFFF800001E;
-    z = 64'hFFDFFFFFEFFFFF80;
-    ans = 64'hFFDFFFFFEFFFFF80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"684609\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"685223\n");
-    end
-    x = 64'hC1EE000000000020;
-    y = 64'h3FD000000007BFFF;
-    z = 64'h8010000000000000;
-    ans = 64'hC1CE0000000E881E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"685837\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hC010000000000001;
-    z = 64'h87A0100000001FFE;
-    ans = 64'hBCC0000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"686451\n");
-    end
-    x = 64'h4377FFFFFBFFFFFE;
-    y = 64'hBFDCFFFFFFFFFFFE;
-    z = 64'h4003FFF7FFFFFFFF;
-    ans = 64'hC365BFFFFC5FFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"687065\n");
-    end
-    x = 64'h8E89B3D545ADB9EA;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"687679\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hBFB00000000200FF;
-    z = 64'hBE37FFFFFFFFFFDF;
-    ans = 64'hBE380000007FFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"688293\n");
-    end
-    x = 64'h47F940B6FC43B061;
-    y = 64'hC340000000000000;
-    z = 64'hF56FFFFB7FFFFFFF;
-    ans = 64'hF56FFFFB7FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"688907\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hC00FFFFFFFFFFF02;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FDFFFFFFFFFFFF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"689521\n");
-    end
-    x = 64'h43E0000000080007;
-    y = 64'h43E1000040000000;
-    z = 64'h381FFFFFFFFF83FE;
-    ans = 64'h47D1000040088008;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"690135\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hBFF0000000000000;
-    ans = 64'hC008000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"690749\n");
-    end
-    x = 64'hEE0000000000037F;
-    y = 64'h40ABFFFFF7FFFFFF;
-    z = 64'h8000000000000001;
-    ans = 64'hEEBBFFFFF800061D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"691363\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hFFE0000000000000;
-    z = 64'hC0BFFFF7FFFFFFF6;
-    ans = 64'hFC90000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"691977\n");
-    end
-    x = 64'h3EB001FFFFFFFFFE;
-    y = 64'hBFB00010000FFFFE;
-    z = 64'h802A8ECA25EFF308;
-    ans = 64'hBE700210021001FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"692591\n");
-    end
-    x = 64'h41600801FFFFFFFF;
-    y = 64'hFFE0000000000001;
-    z = 64'hC010000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"693205\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hACDFFFFFFFFF7EFF;
-    z = 64'h3FA0000000000200;
-    ans = 64'h3FA0000000000200;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"693819\n");
-    end
-    x = 64'hC7FFFFFFC00003FE;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hBFBFFFE000001FFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"694433\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hC470000020000000;
-    z = 64'h3FD0000000000001;
-    ans = 64'hC11FFFFF40000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"695047\n");
-    end
-    x = 64'hC056EDE19622E177;
-    y = 64'hBEC003FFEFFFFFFF;
-    z = 64'hC03FF7FFFFF7FFFF;
-    ans = 64'hC03FF7F486298432;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"695661\n");
-    end
-    x = 64'h3CA0000000000001;
-    y = 64'hFFF0000000000001;
-    z = 64'hBFE0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"696275\n");
-    end
-    x = 64'hC80F000000001FFF;
-    y = 64'h458088C216B51E42;
-    z = 64'h7FFFFFFFFFFFFFFF;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h3E50000000001800;
     ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"696889\n");
+    	$fwrite(fp,"663101\n");
     end
-    x = 64'h3CA0000000000001;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hBAFFFFE000003FFF;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFFFFF7FFDFFFFFF;
+    ReadData2E = 64'hBF8392D6EC4E306A;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hFFFFFF7FFDFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"697503\n");
+    	$fwrite(fp,"663407\n");
     end
-    x = 64'h3F9FFFFFFC07FFFE;
-    y = 64'h43FEA1961EA52621;
-    z = 64'hAA7DFFFFFFFDFFFF;
-    ans = 64'h43AEA1961AD89BC1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"698117\n");
-    end
-    x = 64'h3FDBC2FC6A07DACB;
-    y = 64'h0000000000000000;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"698731\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h41E0001000000000;
-    z = 64'h37F0000000BFFFFF;
-    ans = 64'h3EA0000FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"699345\n");
-    end
-    x = 64'h480007FFFFFFF7FF;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h3EBFEFFC00000000;
-    ans = 64'h3EBFEFFC00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"699959\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hB81000007FFFFFFE;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"700573\n");
-    end
-    x = 64'h41E1FFFFFF7FFFFE;
-    y = 64'hB81207FFFFFFFFFF;
-    z = 64'hAD7000080007FFFF;
-    ans = 64'hBA0448FFFF6FBFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"701187\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h0010000000000000;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"701801\n");
-    end
-    x = 64'hC01FFDFFFFFE0000;
-    y = 64'h3FC0008000003FFF;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"702415\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hAA100008003FFFFF;
-    ans = 64'hAA100008003FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"703029\n");
-    end
-    x = 64'hC349DB908A4890C2;
-    y = 64'hC3CFFFFFFC07FFFF;
-    z = 64'hC3F000FFFF7FFFFF;
-    ans = 64'h4729DB9087139592;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"703643\n");
-    end
-    x = 64'hC1D00000803FFFFF;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"704257\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h357AA218DB1B86F0;
-    z = 64'hC04A768475032095;
-    ans = 64'hC04A768475032095;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"704871\n");
-    end
-    x = 64'hCB6C57A1E8AE7848;
-    y = 64'h3CA0000000000001;
-    z = 64'h440FF00000000200;
-    ans = 64'hC81C57A1E8AE784A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"705485\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hD1112CAD3B4C5218;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'hCDD12CAD3B4C5217;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"706099\n");
-    end
-    x = 64'h41CFC00400000000;
-    y = 64'h40FFFFFF81FFFFFF;
-    z = 64'h532FFFFFFFFDDFFE;
-    ans = 64'h532FFFFFFFFDDFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"706713\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBCAFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"707327\n");
-    end
-    x = 64'h800001FBFFFFFFFF;
-    y = 64'h252000000000203F;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"707941\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h3FD0000000000001;
-    z = 64'hBF4200000001FFFF;
-    ans = 64'hBF4200000001FDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"708555\n");
-    end
-    x = 64'h43E3D73EF74F964F;
-    y = 64'hD51FFFE0000003FE;
-    z = 64'hC0311B57B645A4AC;
-    ans = 64'hD913D72B2010A179;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"709169\n");
-    end
-    x = 64'hC3CFFFFFEFFFFFFA;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hBFF0000000000000;
-    ans = 64'hC3BFFFFFEFFFFFF9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"709783\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h7FFFD9879D865521;
-    z = 64'hBCAE2425EBD33EF3;
-    ans = 64'h7FFFD9879D865521;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"710397\n");
-    end
-    x = 64'hC801212E737DEEDD;
-    y = 64'h3FE0000000000000;
-    z = 64'hC1E000000002FFFF;
-    ans = 64'hC7F1212E737DEEDD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"711011\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h43EFE00000000FFF;
-    z = 64'h0010000000000000;
-    ans = 64'h40AFE00000000FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"711625\n");
-    end
-    x = 64'hC7F00FFFFFFFFFDF;
-    y = 64'h06AAB018F1034A95;
-    z = 64'h426FFFFFFE003FFE;
-    ans = 64'h426FFFFFFE003FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"712239\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'hBCA0000000000000;
-    ans = 64'h3C9FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"712853\n");
-    end
-    x = 64'hFFD4BE7F3DBDF4C8;
-    y = 64'hFFEFFFFFFFFEFC00;
-    z = 64'h4340000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"713467\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h3FF0000000000000;
-    z = 64'hBFCA84F360B6B606;
-    ans = 64'hBFCA84F360B6B5FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"714081\n");
-    end
-    x = 64'h4035891D30C0B3AA;
-    y = 64'hC341021685229DA4;
-    z = 64'h800FFFFFC0007FFF;
-    ans = 64'hC386E47E772D5436;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"714695\n");
-    end
-    x = 64'h2D3FFFFFFFC1FFFE;
-    y = 64'h3FF0000000000001;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"715309\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h434FFFFFFFFEFF00;
-    z = 64'hC7FFFBFFFFFF7FFF;
-    ans = 64'hC7FFFBFFFFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"715923\n");
-    end
-    x = 64'h3FCFFFFFFFFCFFFE;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h9C300000008000FF;
-    ans = 64'h3FDFFFFFFFFCFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"716537\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hC3E87114AD0D0CDC;
-    z = 64'h0000000000000001;
-    ans = 64'hC0A87114AD0D0CDB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"717151\n");
-    end
-    x = 64'h3E00027FFFFFFFFF;
-    y = 64'h3CAE000020000000;
-    z = 64'hBCA2000000000080;
-    ans = 64'hBCA1FFFFFFC3F720;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"717765\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h4000000000000001;
-    z = 64'h8010000000000001;
-    ans = 64'h3CC0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"718379\n");
-    end
-    x = 64'h3D780000000003FF;
-    y = 64'hBF60000003FFFFFE;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"718993\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hA90BB2526EA06D43;
-    ans = 64'h3CCFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"719607\n");
-    end
-    x = 64'h43EFFEF7FFFFFFFF;
-    y = 64'hFFDFFFFFFEFFDFFF;
-    z = 64'h3FD00DFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"720221\n");
-    end
-    x = 64'hC011D00DCFE601AD;
-    y = 64'h4010000000000000;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hC032500DCFE601AD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"720835\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h40300000040003FE;
-    z = 64'hFFF0000000000042;
-    ans = 64'hFFF8000000000042;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"721449\n");
-    end
-    x = 64'hFFFFFFFE00001FFF;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hFFE553153A57374C;
-    ans = 64'hFFFFFFFE00001FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"722063\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h3FE0300000000000;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"722677\n");
-    end
-    x = 64'h43CFFFFBFFF7FFFF;
-    y = 64'h3CA0000001000007;
-    z = 64'h3E5FFFFFFFFFE001;
-    ans = 64'h407FFFFC01FFFFCD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"723291\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h4340000000000000;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h3FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"723905\n");
-    end
-    x = 64'h3810007FFFE00000;
-    y = 64'hBFEFFC0000000FFE;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"724519\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h4010000003DFFFFE;
-    ans = 64'h4020000001EFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"725133\n");
-    end
-    x = 64'h45BFE04000000000;
-    y = 64'hBFD0000002000003;
-    z = 64'h3220000000000200;
-    ans = 64'hC59FE04003FC0806;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"725747\n");
-    end
-    x = 64'h3EF1000000000FFF;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'h4251000000000FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"726361\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hC01FFFFFFFFFFEC0;
-    z = 64'h41E002007FFFFFFF;
-    ans = 64'h41E002007FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"726975\n");
-    end
-    x = 64'h3CA9C1833ECE31D2;
-    y = 64'h7FE0000000000001;
-    z = 64'h400000001FFFFFFF;
-    ans = 64'h7C99C1833ECE31D4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"727589\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hC050000103FFFFFE;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"728203\n");
-    end
-    x = 64'hBF40040000000003;
-    y = 64'h407000000000080F;
-    z = 64'hC0100000010007FF;
-    ans = 64'hC010802001000840;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"728817\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h7FFFFFFFFFFFFFFE;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h4000000000000000;
     ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"729431\n");
+    	$fwrite(fp,"663713\n");
     end
-    x = 64'hCF30000002001FFF;
-    y = 64'hC3ED50F16BE304A9;
-    z = 64'h4000000000000000;
-    ans = 64'h532D50F16F8D5D77;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB6A0000008FFFFFF;
+    ReadData2E = 64'h001FFFFDFFFC0000;
+    ReadData3E = 64'h41EFFEFFFFFFFFC0;
+    ans = 64'h41EFFEFFFFFFFFC0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"730045\n");
+    	$fwrite(fp,"664019\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h7FF0000000000001;
-    z = 64'h47E0000000090000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFD000000400001F;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'hBC80000004000020;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"730659\n");
+    	$fwrite(fp,"664325\n");
     end
-    x = 64'h3FEFFFFFFFDFFFDF;
-    y = 64'hB80FFFF7FFFFFFFD;
-    z = 64'h492FFFFFFFFDFFFA;
-    ans = 64'h492FFFFFFFFDFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBA0FFFFFFFFFFFFE;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'h380FFFFFFFF60000;
+    ans = 64'h380FFFFFFFF60000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"731273\n");
+    	$fwrite(fp,"664631\n");
     end
-    x = 64'hC010040FFFFFFFFF;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'hBCA0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBB50007FFFFFFFFD;
+    ReadData3E = 64'hC1CFFFFFFDFFFFEF;
+    ans = 64'hC1CFFFFFFDFFFFEF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"731887\n");
+    	$fwrite(fp,"664937\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hC1E52E6A88527BEA;
-    z = 64'hB8172BF98589A737;
-    ans = 64'hBEA52E6A88527BE9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"732501\n");
-    end
-    x = 64'h382A6081434E0C86;
-    y = 64'h8000000000000000;
-    z = 64'hC1DE0000000FFFFF;
-    ans = 64'hC1DE0000000FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"733115\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h480FFFE07FFFFFFF;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"733729\n");
-    end
-    x = 64'h3FCFFFFFF8000010;
-    y = 64'hC3CA813954F8319C;
-    z = 64'h37FFFFFFFEFFFFEE;
-    ans = 64'hC3AA81394E57E354;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"734343\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"734957\n");
-    end
-    x = 64'hC1E2E3C25E069868;
-    y = 64'hBF38D24613FBB2E4;
-    z = 64'h3FF0000000000001;
-    ans = 64'h412D4DE5A025F585;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"735571\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h8010000000000000;
-    z = 64'hBA8C582F680D0E8F;
-    ans = 64'hBA8C582F680D0E8F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"736185\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hB8100000000047FE;
-    z = 64'hBE7477104525BE79;
-    ans = 64'hBE7477104525BE79;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"736799\n");
-    end
-    x = 64'h20C000002000000E;
-    y = 64'h8010000000000001;
-    z = 64'h8010000000000001;
-    ans = 64'h8010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"737413\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hC7FFDFFFFFFFFE00;
-    z = 64'hF0B46465EE8EBBB1;
-    ans = 64'hF0B46465EE8EBBB1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"738027\n");
-    end
-    x = 64'h4340000400010000;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hC7F000007FFFFC00;
-    ans = 64'hC7F000007FFFFC00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"738641\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hB7EFFFFFFFFFFFEE;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"739255\n");
-    end
-    x = 64'h4040003FFFFFFFFB;
-    y = 64'h43EC8C7FBE059B61;
-    z = 64'h434FF80000FFFFFF;
-    ans = 64'h443C8D31E004956F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"739869\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hBCA0000000000001;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"740483\n");
-    end
-    x = 64'hB7EFFFFE0000FFFF;
-    y = 64'h40503E9D4BC704B0;
-    z = 64'h3FEFFFFFFFFFFFFF;
+    ReadData1E = 64'h40207FFFFFFBFFFF;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
     ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"741097\n");
+    	$fwrite(fp,"665243\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'hE48FFFFFF7FFFFEE;
-    ans = 64'hE48FFFFFF7FFFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hCF2FFBFFFF000000;
+    ReadData2E = 64'h271FFFE00000000E;
+    ReadData3E = 64'h40C000007FFFFC00;
+    ans = 64'h40C000007FFFFC00;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"741711\n");
+    	$fwrite(fp,"665549\n");
     end
-    x = 64'h7FDF800001000000;
-    y = 64'h499BC83FCE25B88B;
-    z = 64'hC02FFFE000000FFF;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'hBC4000200000007E;
+    ans = 64'hBC4000200000007E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"665855\n");
+    end
+    ReadData1E = 64'h7FFF7FFF7FFFFFFF;
+    ReadData2E = 64'hC3E3FFFF80000000;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h7FFF7FFF7FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"666161\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hBFF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"666467\n");
+    end
+    ReadData1E = 64'h3E2BFD12145D6BEC;
+    ReadData2E = 64'h3FD77C5DA6D45E1A;
+    ReadData3E = 64'hC3D7FFFFFFC00000;
+    ans = 64'hC3D7FFFFFFC00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"666773\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC90FFFFFFFFFFFFF;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'hC5C0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"667079\n");
+    end
+    ReadData1E = 64'hB80FFFFFF7FDFFFE;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFC22F02C76C27CA;
+    ans = 64'hBFC22F02C76C27CA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"667385\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC1D3484EB2F79C31;
+    ReadData3E = 64'hBBB0000001FF7FFF;
+    ans = 64'hBE83484EB2F79CB2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"667691\n");
+    end
+    ReadData1E = 64'h406FFFFFC000000F;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"667997\n");
+    end
+    ReadData1E = 64'h4014A782EDFCB5DA;
+    ReadData2E = 64'hC01000001FFFFFF8;
+    ReadData3E = 64'hBFDFF800001FFFFE;
+    ans = 64'hC0352763174C3BAC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"668303\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'hC2F00080003FFFFF;
+    ans = 64'hC2F00080003FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"668609\n");
+    end
+    ReadData1E = 64'hBFCB16A4DDFFFF66;
+    ReadData2E = 64'h480E26AB973442D3;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC7E985F6B4E7B914;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"668915\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h3FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"669221\n");
+    end
+    ReadData1E = 64'hC01FFFFFFFFFF3FE;
+    ReadData2E = 64'h37E000009FFFFFFF;
+    ReadData3E = 64'hBFD001000001FFFE;
+    ans = 64'hBFD001000001FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"669527\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3FE3BE9E4638F42A;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"669833\n");
+    end
+    ReadData1E = 64'hBD80000FF8000000;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'h79EFFFFFFFFFFFFF;
+    ans = 64'h79EFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"670139\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC1F0000000401FFF;
+    ReadData3E = 64'h3FE1000000001FFF;
+    ans = 64'h3FE0FFFF00001FFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"670445\n");
+    end
+    ReadData1E = 64'hBFC539959DBB1BD9;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"670751\n");
+    end
+    ReadData1E = 64'hABA000FFFF800000;
+    ReadData2E = 64'hC090000000FFFFFE;
+    ReadData3E = 64'h3E1FFFFFFFFFE080;
+    ans = 64'h3E1FFFFFFFFFE080;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"671057\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'hC1F00001FBFFFFFF;
+    ans = 64'hC1F00001FBFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"671363\n");
+    end
+    ReadData1E = 64'h3FE0000003FF7FFF;
+    ReadData2E = 64'hC1D00000000807FF;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'hC1C00000020787FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"671669\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"671975\n");
+    end
+    ReadData1E = 64'hC1FC34B48347777F;
+    ReadData2E = 64'h41F0000000000808;
+    ReadData3E = 64'hC34E4805E11D8622;
+    ans = 64'hC3FC387D8403A958;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"672281\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3F6E674F9B9487B2;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"672587\n");
+    end
+    ReadData1E = 64'hC1BB7F6EF09742E6;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFF830AAB3C2C890;
+    ans = 64'hBFF830AA9843599F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"672893\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBF22A961D8D5A41D;
+    ReadData3E = 64'hC1FFDFFFFFFFF7FF;
+    ans = 64'hC1FFDFFFFFFFF7FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"673199\n");
+    end
+    ReadData1E = 64'h3FF319FB01ADB4BC;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCBB19FB01ADB4BB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"673505\n");
+    end
+    ReadData1E = 64'hBFD346D8CF582601;
+    ReadData2E = 64'hFFD0000000000DFF;
+    ReadData3E = 64'hC800208000000000;
+    ans = 64'h7FB346D8CF5836DE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"673811\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'h434FFFFFEFEFFFFF;
+    ans = 64'h434FFFFFEFEFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"674117\n");
+    end
+    ReadData1E = 64'h000FFFFFFFF7FFF6;
+    ReadData2E = 64'hC3E0000002200000;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hBFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"674423\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FCFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"674729\n");
+    end
+    ReadData1E = 64'hBFEBB35F44DCC45E;
+    ReadData2E = 64'hB88EA4683179AA7F;
+    ReadData3E = 64'hBFDA67B4157D037F;
+    ans = 64'hBFDA67B4157D037F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"675035\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC1EFFBFFFFFF7FFF;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"675341\n");
+    end
+    ReadData1E = 64'hCDE000000007FFFF;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'hB8107F68833FB81B;
+    ans = 64'h4DD000000007FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"675647\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBD1F52A155869D56;
+    ReadData3E = 64'hC00000000800FFFF;
+    ans = 64'hC00000000800FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"675953\n");
+    end
+    ReadData1E = 64'h47FFFFFDFFFFFF7E;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'hC7EFFFFDFFFFFF7C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"676259\n");
+    end
+    ReadData1E = 64'hC15001FFFFFEFFFF;
+    ReadData2E = 64'h0010000C00000000;
+    ReadData3E = 64'h58700000037FFFFE;
+    ans = 64'h58700000037FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"676565\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'hA8B18549F87BF9E4;
+    ans = 64'hBC90000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"676871\n");
+    end
+    ReadData1E = 64'h43FFFBFFFEFFFFFF;
+    ReadData2E = 64'h683FFFFFF8000800;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h6C4FFBFFF70107FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"677177\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCA8000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"677483\n");
+    end
+    ReadData1E = 64'h3FF002000000000F;
+    ReadData2E = 64'h401FFFFF80000002;
+    ReadData3E = 64'h3F339027CC991E83;
+    ans = 64'h40200226E0479942;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"677789\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h40A003FFFFFF0000;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"678095\n");
+    end
+    ReadData1E = 64'h3FDFFFF8007FFFFF;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'h4030009000000000;
+    ans = 64'h402F81201FFE0000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"678401\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h4025C56E3B070359;
+    ReadData3E = 64'h4530020000000000;
+    ans = 64'h4530020000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"678707\n");
+    end
+    ReadData1E = 64'hC01FC0001FFFFFFE;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h401FC0001FFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"679013\n");
+    end
+    ReadData1E = 64'h43F00000000000FD;
+    ReadData2E = 64'h7FE001FE00000000;
+    ReadData3E = 64'hC340001800000000;
     ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"742325\n");
+    	$fwrite(fp,"679319\n");
     end
-    x = 64'hC1E0001FC0000000;
-    y = 64'hBFD0000000000000;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h41C0001FC0000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FDFFFFF7FFFFF00;
+    ans = 64'h7FDFFFFF7FFFFF00;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"742939\n");
+    	$fwrite(fp,"679625\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h3FF03FFFFF7FFFFF;
-    z = 64'hB7ED50191FEBB6C0;
-    ans = 64'h3CB03FFFFF7FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC6D0100FFFFFFFFF;
+    ReadData2E = 64'hC800000000800006;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'h4EE0101000808085;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"743553\n");
+    	$fwrite(fp,"679931\n");
     end
-    x = 64'hFFD0000000037FFE;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h434FFAFFFFFFFFFF;
-    ans = 64'h7FC0000000037FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'hBCA0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"744167\n");
+    	$fwrite(fp,"680237\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hBF7DFFFF7FFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFF;
+    ReadData1E = 64'h801FFFFFFFFFFFDD;
+    ReadData2E = 64'h400FDFFFFFEFFFFE;
+    ReadData3E = 64'hB81FFC0008000000;
+    ans = 64'hB81FFC0008000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"680543\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hB7E1F816D741E8FF;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
     ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"744781\n");
+    	$fwrite(fp,"680849\n");
     end
-    x = 64'h98D4F4367275AF07;
-    y = 64'h3FEFF80003FFFFFF;
-    z = 64'h802FFFFC00000007;
-    ans = 64'h98D4EEF967779869;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC7E200000007FFFF;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'hBFC0000020020000;
+    ans = 64'h47E2000000080000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"745395\n");
+    	$fwrite(fp,"681155\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hBFE0000000000000;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3FB081FFFFFFFFFE;
+    ReadData3E = 64'hBCA001FFFFFFFFE0;
+    ans = 64'hBC9DF3BFFFFFFFC0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"746009\n");
+    	$fwrite(fp,"681461\n");
     end
-    x = 64'h3F9D0C184AFAD181;
-    y = 64'hFFE001E000000000;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'hFF8D0F7FB5D39AE6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h40200FBFFFFFFFFF;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'hC0300FBFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"746623\n");
+    	$fwrite(fp,"681767\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hBFE0000000000001;
-    z = 64'h43F03F7FFFFFFFFF;
-    ans = 64'h43F03F7FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3DBD04283127119A;
+    ReadData2E = 64'hBFBFFF7FFFFFFEFF;
+    ReadData3E = 64'hC80FFBFFFFFFFFFA;
+    ans = 64'hC80FFBFFFFFFFFFA;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"747237\n");
+    	$fwrite(fp,"682073\n");
     end
-    x = 64'h0006BAA6E6628D4B;
-    y = 64'h3D2FFFF000002000;
-    z = 64'hBFEEFFFFFFFFC000;
-    ans = 64'hBFEEFFFFFFFFC000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hB7F800000003FFFF;
+    ans = 64'hBCB0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"747851\n");
+    	$fwrite(fp,"682379\n");
     end
-    x = 64'h3FB002000000FFFF;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h7FFFFFFFFFFFFFFE;
+    ReadData1E = 64'hED3FFFFFFDFFDFFE;
+    ReadData2E = 64'hC1EFF7FFFFDFFFFF;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h6F3FF7FFFDE06005;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"682685\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'hBCB0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"682991\n");
+    end
+    ReadData1E = 64'hBEAFFFFFFC080000;
+    ReadData2E = 64'h403F7FFFFFFFFDFF;
+    ReadData3E = 64'h3FC0000000000807;
+    ans = 64'h3FBFFE0800004E90;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"683297\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h9052000000000000;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h400FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"683603\n");
+    end
+    ReadData1E = 64'h458FFFFC0000007F;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'hBFB0007FFEFFFFFE;
+    ans = 64'hC59FFFFC0000007F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"683909\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3FDFFFFFFF07FFFE;
+    ReadData3E = 64'hBF4FFFFFFFEFFEFF;
+    ans = 64'hBF4FFFFFFFEFFCFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"684215\n");
+    end
+    ReadData1E = 64'h3E90001001000000;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"684521\n");
+    end
+    ReadData1E = 64'hB7E0100000000000;
+    ReadData2E = 64'hC00F7FFDFFFFFFFF;
+    ReadData3E = 64'h3FD0000001000040;
+    ans = 64'h3FD0000001000040;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"684827\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFCFFFFF00000100;
+    ans = 64'hBFCFFFFF00000110;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"685133\n");
+    end
+    ReadData1E = 64'h3E7D7FFFFFFFFFFE;
+    ReadData2E = 64'hBEA0010000001000;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hBD2DA1D800001D7E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"685439\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'hBCC0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"685745\n");
+    end
+    ReadData1E = 64'hB80FFEFFFFFFF000;
+    ReadData2E = 64'hB80000000FFF8000;
+    ReadData3E = 64'hBFDFFFFFFFBC0000;
+    ans = 64'hBFDFFFFFFFBC0000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"686051\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h6AB32A11A3CA63BC;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'h67632A11A3CA63BD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"686357\n");
+    end
+    ReadData1E = 64'hC2E44ABF8AECE4F4;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'h3A000FFE00000000;
+    ans = 64'h43044ABF8AECE4F4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"686663\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h7FDE000003FFFFFF;
+    ReadData3E = 64'hFFD5FFFFFFFFFFFF;
+    ans = 64'hFFD5FFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"686969\n");
+    end
+    ReadData1E = 64'h82C0000180000000;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"687275\n");
+    end
+    ReadData1E = 64'hFFDFAEFD5C6B7ABA;
+    ReadData2E = 64'h00220E29C3D865C9;
+    ReadData3E = 64'h89013D056D7CB36A;
+    ans = 64'hC011E0746CF21C59;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"687581\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'h12EFFFFFFFF007FF;
+    ans = 64'hBCC0000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"687887\n");
+    end
+    ReadData1E = 64'hFFF0400000000100;
+    ReadData2E = 64'h3F4FFBFFFFFFEFFF;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'hFFF8400000000100;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"688193\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"688499\n");
+    end
+    ReadData1E = 64'h381FFFFFFD7FFFFF;
+    ReadData2E = 64'h403FFFE000000001;
+    ReadData3E = 64'hC0107FFF7FFFFFFE;
+    ans = 64'hC0107FFF7FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"688805\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h3FE0080000000008;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h3FF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"689111\n");
+    end
+    ReadData1E = 64'h37E000007FFFFFFD;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'hBF5DF62C415BD684;
+    ans = 64'hBF5DF62C415BD684;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"689417\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC3FFFFFFFFFFFFFE;
+    ReadData3E = 64'h3F10000002FFFFFF;
+    ans = 64'hC0AFFFFFF7FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"689723\n");
+    end
+    ReadData1E = 64'hCC82000000001FFF;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h4FD2000000001FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"690029\n");
+    end
+    ReadData1E = 64'h4035714CDD36D597;
+    ReadData2E = 64'hD99008000001FFFF;
+    ReadData3E = 64'h7FDE800000000000;
+    ans = 64'h7FDE800000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"690335\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'h477FFE0000200000;
+    ans = 64'h477FFE0000200000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"690641\n");
+    end
+    ReadData1E = 64'hDA2001FFFFFFF000;
+    ReadData2E = 64'hCE77EAC3142B09A3;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h68A7EDC06C8D7719;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"690947\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"691253\n");
+    end
+    ReadData1E = 64'hC2EFFFFFFFE0007E;
+    ReadData2E = 64'hBFE745C4C8FE6D0F;
+    ReadData3E = 64'h402000008000007E;
+    ans = 64'h42E745C4C8E728A6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"691559\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC00FFFEFFFFF7FFE;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hBFF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"691865\n");
+    end
+    ReadData1E = 64'h41300010000FFFFE;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FD1000000001FFE;
+    ans = 64'hC4900010000FFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"692171\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hBFBFFFFDEFFFFFFE;
+    ReadData3E = 64'hBF00000000000BFF;
+    ans = 64'hBF000000000013FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"692477\n");
+    end
+    ReadData1E = 64'hBCA4DA12D074B723;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'hC33FFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"692783\n");
+    end
+    ReadData1E = 64'hC0F000000000013F;
+    ReadData2E = 64'hC3F00080000000FF;
+    ReadData3E = 64'hC3E80A604241B1B5;
+    ans = 64'h44F00073FACFE11D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"693089\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'hA25FEFFFFFF00000;
+    ans = 64'hFC90000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"693395\n");
+    end
+    ReadData1E = 64'hC1B000040FFFFFFF;
+    ReadData2E = 64'h429003FFFFC00000;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'hC450040410C3FFEF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"693701\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'hFC90000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"694007\n");
+    end
+    ReadData1E = 64'h400000000000807F;
+    ReadData2E = 64'hBFB00000807FFFFF;
+    ReadData3E = 64'hC1CFFFFFFFF003FF;
+    ans = 64'hC1D0000000000200;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"694313\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hB81FFFFFDC000000;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h3FDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"694619\n");
+    end
+    ReadData1E = 64'hC00FFFFFDFF7FFFE;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hC01000010000007F;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"694925\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC3D8C4C50B88973B;
+    ReadData3E = 64'h3FF801FFFFFFFFFE;
+    ans = 64'hC088B8C40B88973D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"695231\n");
+    end
+    ReadData1E = 64'h41F00000FFFFFFFD;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"695537\n");
+    end
+    ReadData1E = 64'h4000000001FFFFFF;
+    ReadData2E = 64'hC03D3AEEE26F78DA;
+    ReadData3E = 64'h4070200001000000;
+    ans = 64'h4068F144487A4A53;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"695843\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'h38000000008000FF;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"696149\n");
+    end
+    ReadData1E = 64'h801FFFFFFFFFFFFE;
+    ReadData2E = 64'h47F0080200000000;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
     ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"748465\n");
+    	$fwrite(fp,"696455\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hB32832CD4DA733A1;
-    z = 64'hB7F0010000100000;
-    ans = 64'hB7F0010000100000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"749079\n");
+    	$fwrite(fp,"696761\n");
     end
-    x = 64'hC3FFFFFF04000000;
-    y = 64'hBFF0000000000001;
-    z = 64'hBCBFFFFFFFFF0006;
-    ans = 64'h43FFFFFF04000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB80FC10000000000;
+    ReadData2E = 64'hC3FFFDFFFFFFFEFF;
+    ReadData3E = 64'h491C0000001FFFFF;
+    ans = 64'h491C0000001FFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"749693\n");
+    	$fwrite(fp,"697067\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h41E7FFFFFFFFFFFC;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFF9FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hC0327E3DBCE6EF3A;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'hBFD0000000000025;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"750307\n");
+    	$fwrite(fp,"697373\n");
     end
-    x = 64'hA253DCAE002F464A;
-    y = 64'hE920001000000080;
-    z = 64'h0020000000FEFFFF;
-    ans = 64'h4B83DCC1DCDD4718;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC0153BC492FC310A;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h8000001FFEFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"750921\n");
+    	$fwrite(fp,"697679\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h401FFFFFFFFFFFFE;
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'h37F139BA63EE665E;
+    ReadData3E = 64'hB7E0000000002040;
+    ans = 64'hB7E000000000203F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"697985\n");
+    end
+    ReadData1E = 64'h47F4000000007FFF;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"698291\n");
+    end
+    ReadData1E = 64'h00000001FFFFFF00;
+    ReadData2E = 64'h3FCFFF9FFFFFFFFE;
+    ReadData3E = 64'h381FFFFFFFFFEFBF;
+    ans = 64'h381FFFFFFFFFEFBF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"698597\n");
+    end
+    ReadData1E = 64'h3CA0000000000001;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFFF5FFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"698903\n");
+    end
+    ReadData1E = 64'hBC505D00DA08A9C0;
+    ReadData2E = 64'hC6A24FCBC7903757;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"699209\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h4010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"699515\n");
+    end
+    ReadData1E = 64'h3FFAC71E6E51C317;
+    ReadData2E = 64'h91B0000000003FEF;
+    ReadData3E = 64'h43E80957D015CBB2;
+    ans = 64'h43E80957D015CBB2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"699821\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFE000013FFFFFFF;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'hFCA000013FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"700127\n");
+    end
+    ReadData1E = 64'hC1D21AEBDD830161;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'hC03FFFFEFFFFFFFE;
+    ans = 64'hC03FFFFEFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"700433\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h4FC1D94A43C02150;
+    ReadData3E = 64'hB7E001FDFFFFFFFF;
+    ans = 64'h4C81D94A43C0214F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"700739\n");
+    end
+    ReadData1E = 64'h4070B5D5F5B8F37E;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"701045\n");
+    end
+    ReadData1E = 64'h2A20000010000800;
+    ReadData2E = 64'h3EDFFFFFDBFFFFFF;
+    ReadData3E = 64'hC01C22E3E5DB9124;
+    ans = 64'hC01C22E3E5DB9124;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"701351\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h4B2FFFFFFFB7FFFF;
+    ans = 64'h4B2FFFFFFFB7FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"701657\n");
+    end
+    ReadData1E = 64'hC3F3FEFFFFFFFFFF;
+    ReadData2E = 64'h7FE000000002007F;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"701963\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hC00FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"702269\n");
+    end
+    ReadData1E = 64'h3F60000001FFFFEE;
+    ReadData2E = 64'h0000000007FFFFFD;
+    ReadData3E = 64'hC1CFFFFFFEBFFFFF;
+    ans = 64'hC1CFFFFFFEBFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"702575\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h401FFFFFFFFC07FF;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h3CDFFFFFFFFC07FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"702881\n");
+    end
+    ReadData1E = 64'hC2FFFFFE000007FF;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'h835003FFF7FFFFFF;
+    ans = 64'h835203FFD800007F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"703187\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h0B700000004003FF;
+    ReadData3E = 64'h002000FFFFFFEFFF;
+    ans = 64'h08300000004003FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"703493\n");
+    end
+    ReadData1E = 64'h3FA001FFE0000000;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"703799\n");
+    end
+    ReadData1E = 64'h4040800200000000;
+    ReadData2E = 64'h3FC7D33A1738766D;
+    ReadData3E = 64'h8000000007FFFF7F;
+    ans = 64'h401891D6E2597D07;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"704105\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'h8018A1B4427BBEB8;
+    ans = 64'h8018A1B4427BBEB6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"704411\n");
+    end
+    ReadData1E = 64'h37FFFFF3FFFFFFFE;
+    ReadData2E = 64'hBFB0100000000002;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"704717\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"705023\n");
+    end
+    ReadData1E = 64'hC0A000000000FFFE;
+    ReadData2E = 64'hC3FFFFFFFFFFFFB8;
+    ReadData3E = 64'hB7E01FFFFFFFFF80;
+    ans = 64'h44B000000000FFDA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"705329\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC34F0AC72AA75605;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'hC00F0AC72AA75604;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"705635\n");
+    end
+    ReadData1E = 64'hB86FFFFFFF820000;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'hB8D00002000FFFFF;
+    ans = 64'hB8D00002000FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"705941\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h41DFFFFFE00001FF;
+    ReadData3E = 64'h41C3C27FCF1953FB;
+    ans = 64'h41C3C27FCF1953FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"706247\n");
+    end
+    ReadData1E = 64'hBF3003F7FFFFFFFF;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h3FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"706553\n");
+    end
+    ReadData1E = 64'h40AFFFFFFFBEFFFF;
+    ReadData2E = 64'hC1F5BB80746EB9E1;
+    ReadData3E = 64'h7FD7FFFFFBFFFFFE;
+    ans = 64'h7FD7FFFFFBFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"706859\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h3F8FFFFEFFFFFFBF;
+    ans = 64'h3F8FFFFEFFFFFFBF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"707165\n");
+    end
+    ReadData1E = 64'hC7D0007FEFFFFFFF;
+    ReadData2E = 64'hC18CE14D9BCE0B02;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h496CE23489599BD5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"707471\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"707777\n");
+    end
+    ReadData1E = 64'hC1F2000FFFFFFFFF;
+    ReadData2E = 64'h4020000000080008;
+    ReadData3E = 64'h4030003FFFFF7FFF;
+    ans = 64'hC222000FFFE8FF90;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"708083\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h5D100000003FFFFE;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h59D00000003FFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"708389\n");
+    end
+    ReadData1E = 64'hDD90003FFFFFEFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'hBA1FF7FFFFFFE000;
+    ans = 64'hDA50003FFFFFEFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"708695\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h47EFF0001FFFFFFE;
+    ReadData3E = 64'hC1E0001FFFFFFFFF;
+    ans = 64'h44AFF0001FFFFEFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"709001\n");
+    end
+    ReadData1E = 64'hB81FFFFFF7F7FFFF;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"709307\n");
+    end
+    ReadData1E = 64'h5CBD7EB455888645;
+    ReadData2E = 64'hBCA010000000007F;
+    ReadData3E = 64'h40E3FFFFFFFFFFFE;
+    ans = 64'hD96D9C3309DE0FB5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"709613\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'hBF51E1746AB411A1;
+    ans = 64'hBF51E1746AB410A1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"709919\n");
+    end
+    ReadData1E = 64'h3CAFFFFFE3FFFFFF;
+    ReadData2E = 64'hC0200000FEFFFFFF;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC010000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"710225\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h3FE0000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"710531\n");
+    end
+    ReadData1E = 64'h802DB8D352BF1533;
+    ReadData2E = 64'h3ED78B4045674233;
+    ReadData3E = 64'hFFDFFFBF7FFFFFFF;
+    ans = 64'hFFDFFFBF7FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"710837\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h43C000000000021E;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"711143\n");
+    end
+    ReadData1E = 64'hBF9FFFFFFF000007;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'hC090001FFFFFFFFF;
+    ans = 64'hC090002FFFFFFF7F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"711449\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFA0000000007FC0;
+    ReadData3E = 64'h802F6FEF6C4FB6E9;
+    ans = 64'hBC60000000007FBF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"711755\n");
+    end
+    ReadData1E = 64'h3F3BFBFFFFFFFFFF;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h3F2BFC0000001FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"712061\n");
+    end
+    ReadData1E = 64'h4142CAC584401A28;
+    ReadData2E = 64'hFFDBAC0C29D4EE17;
+    ReadData3E = 64'hBFB003EAEA289C1E;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"712367\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'hBDF82D162E8BAF54;
+    ans = 64'hBDF82D15AE8BAF54;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"712673\n");
+    end
+    ReadData1E = 64'h40FFFF000003FFFF;
+    ReadData2E = 64'hC0088FAE85CFB9E8;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'hC1188EE2085E9D5F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"712979\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFDFFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"713285\n");
+    end
+    ReadData1E = 64'h9ECF000000004000;
+    ReadData2E = 64'h7FEFFFFBFFFFFF80;
+    ReadData3E = 64'hC1DFFFFF80001FFE;
+    ans = 64'hDECEFFFC20003F84;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"713591\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC7F5FAB540D0DED9;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"713897\n");
+    end
+    ReadData1E = 64'hBFDFFFFFFC3FFFFE;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hBF6E00000000003F;
+    ans = 64'hBFE01DFFFE1FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"714203\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h406FFFFFEFFFFDFF;
+    ReadData3E = 64'hB211FFFD53E700AE;
+    ans = 64'h3D2FFFFFEFFFFDFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"714509\n");
+    end
+    ReadData1E = 64'h002FFFFDFFFEFFFE;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hBCA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"714815\n");
+    end
+    ReadData1E = 64'hC7F00000020003FF;
+    ReadData2E = 64'hBFE00021FFFFFFFF;
+    ReadData3E = 64'hC0AFF800003FFFFF;
+    ans = 64'h47E000220200083E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"715121\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'hB81D1619C3444AAD;
+    ans = 64'h3CAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"715427\n");
+    end
+    ReadData1E = 64'hC3C8F81F205C84C5;
+    ReadData2E = 64'hBD9000007FFFFFF7;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'h4168F81FA81D7DBA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"715733\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h3CBFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"716039\n");
+    end
+    ReadData1E = 64'hBFBFFFFFFC3FFFFF;
+    ReadData2E = 64'h3FBFFF0000007FFF;
+    ReadData3E = 64'h3F8FFFFFFFFFFE03;
+    ans = 64'h3EC0003BF6005000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"716345\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC04FDFFBFFFFFFFE;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"716651\n");
+    end
+    ReadData1E = 64'h43CFFFFFFFFF3FFF;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFCBFECEE81F8C27;
+    ans = 64'h43DFFFFFFFFF3FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"716957\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FE0000000000036;
+    ReadData3E = 64'hBFC0080000200000;
+    ans = 64'hBFC00800001FFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"717263\n");
+    end
+    ReadData1E = 64'h41EA89148D512055;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h41FA89148D512053;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"717569\n");
+    end
+    ReadData1E = 64'h390FFFFEFFFF7FFE;
+    ReadData2E = 64'h40B1FFFFFFFF0000;
+    ReadData3E = 64'h224FFFFFF8000006;
+    ans = 64'h39D1FFFF6FFEB7FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"717875\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h37F000003BFFFFFF;
+    ans = 64'h3CBFFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"718181\n");
+    end
+    ReadData1E = 64'h71EFFFF7FFFFFDFF;
+    ReadData2E = 64'h8008BDF18FA06A55;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'h3FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"718487\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'h3CB7FFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"718793\n");
+    end
+    ReadData1E = 64'h3FCFFFFFFF800007;
+    ReadData2E = 64'h7FD3FFFFFFFFF000;
+    ReadData3E = 64'h380E3FFFFFFFFFFF;
+    ans = 64'h7FB3FFFFFFAFF004;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"719099\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h41EFFFFCFFFFFFFF;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h4340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"719405\n");
+    end
+    ReadData1E = 64'h3FF00000000000EE;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'h15D0000002000FFF;
+    ans = 64'h40000000000000EF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"719711\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBF13670077E329FC;
+    ReadData3E = 64'h66EFFFEFFFFFFFFC;
+    ans = 64'h66EFFFEFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"720017\n");
+    end
+    ReadData1E = 64'hBF00005FFFFFFFFF;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'hBF20005FFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"720323\n");
+    end
+    ReadData1E = 64'h483FFFFFFFFF7FBE;
+    ReadData2E = 64'h51300400000003FE;
+    ReadData3E = 64'h37E0008000400000;
+    ans = 64'h598003FFFFFFC3CD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"720629\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'hC01000000007FFFB;
+    ans = 64'hC01000000007FFFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"720935\n");
+    end
+    ReadData1E = 64'h802FFFFFFF000080;
+    ReadData2E = 64'h3F00000000FFFFE0;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hBFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"721241\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h3CCFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"721547\n");
+    end
+    ReadData1E = 64'h3F100007FFFFF7FF;
+    ReadData2E = 64'h5AEFFFFFFFDFFFFD;
+    ReadData3E = 64'hBE7FFFFFFFF7FFFB;
+    ans = 64'h5A100007FFEFF7F5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"721853\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC0E00007FFF7FFFF;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC010000000002001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"722159\n");
+    end
+    ReadData1E = 64'h37FDFDFFFFFFFFFF;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'h2B9BC6B387D1ACCE;
+    ans = 64'h381DFE0000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"722465\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFCFC000000000FE;
+    ReadData3E = 64'hD65E3F9A7F0FAF49;
+    ans = 64'hD65E3F9A7F0FAF49;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"722771\n");
+    end
+    ReadData1E = 64'hB800000800001000;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"723077\n");
+    end
+    ReadData1E = 64'h3FBFF80004000000;
+    ReadData2E = 64'hC06FFFBFFFFFFFFC;
+    ReadData3E = 64'h40300000000007BF;
+    ans = 64'hC02FEF8027FFE07A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"723383\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'h4C40000000000000;
+    ans = 64'h4C40000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"723689\n");
+    end
+    ReadData1E = 64'h3F30001000000007;
+    ReadData2E = 64'h800000000000007E;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"723995\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'h3CDFFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"724301\n");
+    end
+    ReadData1E = 64'hC01FFFFFFFFDFFFB;
+    ReadData2E = 64'h3FE15EA250BE553F;
+    ReadData3E = 64'h3FBFFFFFFFFFFFED;
+    ans = 64'hC010DEA250BD3F52;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"724607\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBF79C78656F15D19;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h400FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"724913\n");
+    end
+    ReadData1E = 64'h41E540947D9D3B75;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'h95FFFBFFFFF7FFFF;
+    ans = 64'h453540947D9D3B75;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"725219\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h400FFDFFFFFFBFFF;
+    ReadData3E = 64'h472FFFFFFFFF81FF;
+    ans = 64'h472FFFFFFFFF81FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"725525\n");
+    end
+    ReadData1E = 64'hD0FFFEFFFFFFFFC0;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"725831\n");
+    end
+    ReadData1E = 64'h401989593420B76C;
+    ReadData2E = 64'hC1E4F4FFF9EF9D25;
+    ReadData3E = 64'h05800FFFFFFFFFC0;
+    ans = 64'hC210B95B4EB4B8D6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"726137\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h40322892719C4A7F;
+    ans = 64'h40362892719C4A7F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"726443\n");
+    end
+    ReadData1E = 64'hBF0998BC3CFD5996;
+    ReadData2E = 64'hEEE00007FFF7FFFF;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'h6DF998C9094EABB5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"726749\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"727055\n");
+    end
+    ReadData1E = 64'h37FCCB1A46C03634;
+    ReadData2E = 64'h40A000400001FFFF;
+    ReadData3E = 64'hB7FFFFFFC00003FF;
+    ans = 64'h38ACC78D7334EA96;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"727361\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h40EF9E572874A507;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hBFFFFFFFFFFF030B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"727667\n");
+    end
+    ReadData1E = 64'hC1F001FFFFFFFFFC;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'hDC492B5C56F6CEC6;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"727973\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h801FFFFFFDFFFEFF;
+    ReadData3E = 64'h43E9488598C128E1;
+    ans = 64'h43E9488598C128E1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"728279\n");
+    end
+    ReadData1E = 64'hC030000000000037;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"728585\n");
+    end
+    ReadData1E = 64'h97200000040001FF;
+    ReadData2E = 64'h7FD00000000003FF;
+    ReadData3E = 64'h00200001EFFFFFFF;
+    ans = 64'hD7000000040005FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"728891\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'h8CCEC95BB8DB66DD;
+    ans = 64'h7CA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"729197\n");
+    end
+    ReadData1E = 64'h417010000FFFFFFF;
+    ReadData2E = 64'hC03FFC0000000000;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'hC1C00DFE0FFDFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"729503\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"729809\n");
+    end
+    ReadData1E = 64'hBDBBFF0000000000;
+    ReadData2E = 64'h802FFFFFFFFC003F;
+    ReadData3E = 64'hC010000006FFFFFF;
+    ans = 64'hC010000006FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"730115\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hB7E2CD542725A7DF;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h3FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"730421\n");
+    end
+    ReadData1E = 64'hC03000000000021F;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h43DE0340FC13DE79;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"730727\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FB0000000002000;
+    ReadData3E = 64'hC4F000000003FFF7;
+    ans = 64'hC4F000000003FFF7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"731033\n");
+    end
+    ReadData1E = 64'h41D3EC019940A24C;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"731339\n");
+    end
+    ReadData1E = 64'hFFE00001FFFFFFF7;
+    ReadData2E = 64'hC01B84F8B54B3138;
+    ReadData3E = 64'hBFC00FFFFFFFFFBF;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"731645\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'h8930007FFFFFFFEF;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"731951\n");
+    end
+    ReadData1E = 64'hBFBFFFFFFF1FFFFE;
+    ReadData2E = 64'h41DFDFC000000000;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'hC1AFDFBFFF20E1BE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"732257\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"732563\n");
+    end
+    ReadData1E = 64'hBF9FFFFE00000000;
+    ReadData2E = 64'h402FFFFFFFFFF80F;
+    ReadData3E = 64'hC3C2F72E444107D4;
+    ans = 64'hC3C2F72E444107D4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"732869\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC06101FFFFFFFFFE;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'hBFE0000000000111;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"733175\n");
+    end
+    ReadData1E = 64'hD28FFFFFFFF800FE;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC3F000000041FFFF;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"733481\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h4010400001FFFFFE;
+    ReadData3E = 64'hBF447AB4C8297DFA;
+    ans = 64'hBF447AB4C8295D7A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"733787\n");
+    end
+    ReadData1E = 64'hC3C32F485BF17E30;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"734093\n");
+    end
+    ReadData1E = 64'hBFB0000400008000;
+    ReadData2E = 64'h480219B474B1BFFE;
+    ReadData3E = 64'h37EFFFFFFFF7FF7E;
+    ans = 64'hC7C219B8FB1F6DF8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"734399\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'h43EFFFFFFFFFFFF3;
+    ans = 64'h43EFFFFFFFFFFFF3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"734705\n");
+    end
+    ReadData1E = 64'h511FFFFF00FFFFFE;
+    ReadData2E = 64'h00000007FFFFFFBF;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'h102FFFFEFFFC0006;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"735011\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h434FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"735317\n");
+    end
+    ReadData1E = 64'h3F8FFBFFFFFFF7FF;
+    ReadData2E = 64'h374FFFF7FFFFBFFE;
+    ReadData3E = 64'h37E01FFFFFFFFFFE;
+    ans = 64'h37E0201FFBF800FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"735623\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h47FFFFFFFFF8001F;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h44BFFFFFFFF8001E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"735929\n");
+    end
+    ReadData1E = 64'hC800000800000040;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
     ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"736235\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h8000000000000028;
+    ReadData3E = 64'h6A28080000000000;
+    ans = 64'h6A28080000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"736541\n");
+    end
+    ReadData1E = 64'hBC6007FFFFFEFFFF;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"736847\n");
+    end
+    ReadData1E = 64'h8000000110000000;
+    ReadData2E = 64'hC2F0000080200000;
+    ReadData3E = 64'h400FBFFFFFFFDFFF;
+    ans = 64'h400FBFFFFFFFDFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"737153\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'hBFBFFDFFFFFFFFBE;
+    ans = 64'hBFBFFDFFFFFFFFBE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"737459\n");
+    end
+    ReadData1E = 64'hC7FFFFFFEFF7FFFF;
+    ReadData2E = 64'h3E8FFFFFBFFFFFFC;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"737765\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hC01FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"738071\n");
+    end
+    ReadData1E = 64'hAD200000000047FE;
+    ReadData2E = 64'h404F2BAADD169721;
+    ReadData3E = 64'hC0C001FEFFFFFFFF;
+    ans = 64'hC0C001FEFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"738377\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hB813FDFFFFFFFFFF;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hBCAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"738683\n");
+    end
+    ReadData1E = 64'h456000000007BFFF;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h4E7FFFFF70000000;
+    ans = 64'h4E7FFFFF70000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"738989\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC1FA8B35CF63049E;
+    ReadData3E = 64'hBFDFF7FDFFFFFFFE;
+    ans = 64'hBFDFF804A2CD73D7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"739295\n");
+    end
+    ReadData1E = 64'h41CD859AA5735B17;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"739601\n");
+    end
+    ReadData1E = 64'h330FFFFFFBFF7FFE;
+    ReadData2E = 64'hC00F7FFFFDFFFFFF;
+    ReadData3E = 64'h3FC00003FFF7FFFE;
+    ans = 64'h3FC00003FFF7FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"739907\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'hC1F007FFFBFFFFFE;
+    ans = 64'hC1F007FFFBFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"740213\n");
+    end
+    ReadData1E = 64'h407FFFFFFF00001E;
+    ReadData2E = 64'h3FF00000000001FB;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"740519\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"740825\n");
+    end
+    ReadData1E = 64'hC0207FFFFFFFF7FE;
+    ReadData2E = 64'hC3FFBFFFEFFFFFFF;
+    ReadData3E = 64'h3FE03FFFFFFFF000;
+    ans = 64'h44305EFFF7BFF80E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"741131\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FFFFFFF80000007;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h3CC3FFFFC0000003;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"741437\n");
+    end
+    ReadData1E = 64'hC1F02007FFFFFFFF;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'hBFD36778D0F4A90A;
+    ans = 64'hBFD36776CCF3A90A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"741743\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h08BFFFFFBFFBFFFE;
+    ReadData3E = 64'hBFD9B3973EE16671;
+    ans = 64'hBFD9B3973EE16671;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"742049\n");
+    end
+    ReadData1E = 64'h36DFFFDFFFFFFF7E;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h3FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"742355\n");
+    end
+    ReadData1E = 64'h401EFFFFFFFF0000;
+    ReadData2E = 64'h41E00000021FFFFF;
+    ReadData3E = 64'h7FF0000001000004;
+    ans = 64'h7FF8000001000004;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"742661\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'hC01FEFFFFFE00000;
+    ans = 64'hC01FEFFFFFE00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"742967\n");
+    end
+    ReadData1E = 64'hC7800047FFFFFFFF;
+    ReadData2E = 64'h3818718D1A7C2293;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"743273\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"743579\n");
+    end
+    ReadData1E = 64'hC24FFFFF80020000;
+    ReadData2E = 64'h37FFFFF400000000;
+    ReadData3E = 64'hC1DFFFFFFFFF0001;
+    ans = 64'hC1DFFFFFFFFF0001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"743885\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3DDFFFFFFFFF000F;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h3A9FFFFFFFFF000E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"744191\n");
+    end
+    ReadData1E = 64'hC0C0041FFFFFFFFF;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'hB81000000FFFFFDF;
+    ans = 64'h40A0041FFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"744497\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC2500003FFFFFFF8;
+    ReadData3E = 64'hC75FFFF7FFFFFFC0;
+    ans = 64'hC75FFFF7FFFFFFC0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"744803\n");
+    end
+    ReadData1E = 64'hDF2007FFFFFEFFFF;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'h5F0007FFFFFF0000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"745109\n");
+    end
+    ReadData1E = 64'h3FB00002007FFFFE;
+    ReadData2E = 64'h47FE08445C9805CA;
+    ReadData3E = 64'hFFDE800000000000;
+    ans = 64'hFFDE800000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"745415\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFFFFF8000002000;
+    ans = 64'hBFFFFF8000002000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"745721\n");
+    end
+    ReadData1E = 64'hC03FFFFFFFC7FFFF;
+    ReadData2E = 64'h403000000000040E;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC340000000000101;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"746027\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h3FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"746333\n");
+    end
+    ReadData1E = 64'hFFD0000023FFFFFE;
+    ReadData2E = 64'hC3DFFFE07FFFFFFF;
+    ReadData3E = 64'hB80FFDFFFFFFFEFF;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"746639\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC03B1DEB7D342DFF;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'hBCFB1DEB7D342DFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"746945\n");
+    end
+    ReadData1E = 64'h37FFC3CD8026EDA0;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'hBEAB43550AFC66D5;
+    ans = 64'hBEAB43550AFC66D5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"747251\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h43C00003FDFFFFFF;
+    ReadData3E = 64'hBEBDFFFFFEFFFFFE;
+    ans = 64'h40800003FD0FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"747557\n");
+    end
+    ReadData1E = 64'hECA939F14EB859D3;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h6C9939F14EB859D5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"747863\n");
+    end
+    ReadData1E = 64'hC7BDA4A9027C7292;
+    ReadData2E = 64'hBFFFF80000000003;
+    ReadData3E = 64'h3EC0FFFFFFFBFFFF;
+    ans = 64'h47CD9D3FD83BD378;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"748169\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'h4030080FFFFFFFFF;
+    ans = 64'h4030080FFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"748475\n");
+    end
+    ReadData1E = 64'h434FFFE000000000;
+    ReadData2E = 64'h43E0007FFFFFFFFD;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h4740006FFF7FFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"748781\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"749087\n");
+    end
+    ReadData1E = 64'h801BFBE73AF53F7E;
+    ReadData2E = 64'hBFFFC0007FFFFFFF;
+    ReadData3E = 64'h480FFFFFF7FDFFFE;
+    ans = 64'h480FFFFFF7FDFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"749393\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3E4000FFF8000000;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"749699\n");
+    end
+    ReadData1E = 64'hBF6FE01000000000;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBE7636E818A167A2;
+    ans = 64'h3F6FDFE3922FCEBB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"750005\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hB32832CD4DA733A1;
+    ReadData3E = 64'hB7F0010000100000;
+    ans = 64'hB7F0010000100000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"750311\n");
+    end
+    ReadData1E = 64'h3CAAA8F7EF2045EC;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hBFD0000000000004;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"750617\n");
+    end
+    ReadData1E = 64'hC0A00FFFFFFF0000;
+    ReadData2E = 64'hC016EE0768D982C6;
+    ReadData3E = 64'hBFEFFC0000000FFF;
+    ans = 64'h40C704758040ED68;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"750923\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'hBEC0000001F7FFFF;
+    ans = 64'hBEC0000001FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"751229\n");
+    end
+    ReadData1E = 64'hB7F2000000000FFF;
+    ReadData2E = 64'h7FDFFFDFFBFFFFFF;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hF7E1FFEDFDC00FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
@@ -57567,7189 +95812,11971 @@ initial
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
     	$fwrite(fp,"751535\n");
     end
-    x = 64'h5750000000000040;
-    y = 64'h400AB0370585F185;
-    z = 64'h3FD0000000000000;
-    ans = 64'h576AB0370585F1F0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h3FDFFFFFFFFFFFF8;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"752149\n");
+    	$fwrite(fp,"751841\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hC000000000000000;
-    z = 64'h3CA2000000000400;
-    ans = 64'hBCB6FFFFFFFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB780000003FFFFDF;
+    ReadData2E = 64'h3FC1FFFFFFBFFFFF;
+    ReadData3E = 64'hBFB6BDB75B174AF1;
+    ans = 64'hBFB6BDB75B174AF1;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"752763\n");
+    	$fwrite(fp,"752147\n");
     end
-    x = 64'hC10DEB4451CF9086;
-    y = 64'h4770100000004000;
-    z = 64'hD5EFFFFEFFFFFFDF;
-    ans = 64'hD5EFFFFEFFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC01FFE0000020000;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"753377\n");
+    	$fwrite(fp,"752453\n");
     end
-    x = 64'hF0863251E8FE0225;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h402FFFFFFFFFFFFE;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h5EFB355B02575E41;
+    ans = 64'h5EFB355B02575E41;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"753991\n");
+    	$fwrite(fp,"752759\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h41F007FFEFFFFFFE;
-    z = 64'h404FFFFFFBFFFFF8;
-    ans = 64'h405000000201FFF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC01000007EFFFFFF;
+    ReadData3E = 64'hC0300100003FFFFF;
+    ans = 64'hC0300100003FFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"754605\n");
+    	$fwrite(fp,"753065\n");
     end
-    x = 64'h3F8FFFE001FFFFFE;
-    y = 64'hC010000000000000;
-    z = 64'h3CA0008000000FFF;
-    ans = 64'hBFAFFFE001FFFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3F400BFFFFFFFFFF;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'hBF500BFFFFFFFBFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"755219\n");
+    	$fwrite(fp,"753371\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h37E71F98C279DBBC;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC018F904A86762F5;
+    ReadData2E = 64'hC0ABCA88E32554C2;
+    ReadData3E = 64'hC2248DCD904C6353;
+    ans = 64'hC2248DCCE2CB0DDA;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"755833\n");
+    	$fwrite(fp,"753677\n");
     end
-    x = 64'h37E00400001FFFFE;
-    y = 64'h43F8400F900F53B5;
-    z = 64'hC3EFFFFFBFFFF7FE;
-    ans = 64'hC3EFFFFFBFFFF7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'h37EFFFFFFFFC01FF;
+    ans = 64'hBCBFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"756447\n");
+    	$fwrite(fp,"753983\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h4010000000000000;
-    ans = 64'h400FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC7FFF7FFFFFFDFFE;
+    ReadData2E = 64'h0010000080000FFF;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'h4000000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"757061\n");
+    	$fwrite(fp,"754289\n");
     end
-    x = 64'hBDE1C565EC0236AF;
-    y = 64'hBCAFFFF000000100;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3CA000000011C55E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hBFD0000000000009;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"757675\n");
+    	$fwrite(fp,"754595\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hC02CBE486A2B0809;
-    ans = 64'hC02CBE486A2B080A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFD79DB1F2CD62F9;
+    ReadData2E = 64'hBABFFFFBFFFFFFFA;
+    ReadData3E = 64'h40B00001FFFFFFFF;
+    ans = 64'h7AA79DAEFF17249B;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"758289\n");
+    	$fwrite(fp,"754901\n");
     end
-    x = 64'hBFDFFDFFFBFFFFFF;
-    y = 64'h3F0F7FFFFFF80000;
-    z = 64'h4D90000000010006;
-    ans = 64'h4D90000000010006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h7FDE00000001FFFF;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000002;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"758903\n");
+    	$fwrite(fp,"755207\n");
     end
-    x = 64'h28A9110868DC09E4;
-    y = 64'hC340000000000001;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h47FFFC0000000FFE;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h43F0000000200002;
+    ans = 64'hC81FFC0000000FFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"759517\n");
+    	$fwrite(fp,"755513\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hC02FBFFFFEFFFFFF;
-    z = 64'h4803ABE97F306C7A;
-    ans = 64'h4803ABE97F306C7A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC02FFFFFDFFFBFFE;
+    ReadData3E = 64'h7FD00000000FFFF6;
+    ans = 64'h7FD00000000FFFF6;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"760131\n");
+    	$fwrite(fp,"755819\n");
     end
-    x = 64'hBFC000000FFFFE00;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h40EBFFFFFEFFFFFF;
-    ans = 64'h432000001001BDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h39B00020000FFFFF;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'hB9D00020000FFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"760745\n");
+    	$fwrite(fp,"756125\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hC7F0000400000003;
-    z = 64'hBFF0000000000001;
-    ans = 64'hC4B0000400000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB588000800000000;
+    ReadData2E = 64'h000BBA2331B70CC7;
+    ReadData3E = 64'hADC0FFFFFFFBFFFF;
+    ans = 64'hADC0FFFFFFFBFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"761359\n");
+    	$fwrite(fp,"756431\n");
     end
-    x = 64'hBEF2000000001FFE;
-    y = 64'h41D9A46BD6DA0E6B;
-    z = 64'h001FFFFFEFFFFF7F;
-    ans = 64'hC0DCD8F951B5837E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'hC3FFFFC002000000;
+    ans = 64'hC3FFFFC002000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"761973\n");
+    	$fwrite(fp,"756737\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hFFE0000000000001;
-    z = 64'h4000000000000001;
-    ans = 64'hFCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h418000000007FFE0;
+    ReadData2E = 64'hBFD00003FFFBFFFE;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hC16000042003FFE0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"762587\n");
+    	$fwrite(fp,"757043\n");
     end
-    x = 64'h000667C5D67E1D85;
-    y = 64'h3FDFEFFFFDFFFFFF;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h002199247CCB1886;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'hBCC8000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"763201\n");
+    	$fwrite(fp,"757349\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h43DC000001000000;
-    ans = 64'hFCAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBCAC000000000003;
+    ReadData2E = 64'h41F0000000001E00;
+    ReadData3E = 64'h403000000000000A;
+    ans = 64'h402FFFFFE4000014;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"763815\n");
+    	$fwrite(fp,"757655\n");
     end
-    x = 64'h400FFFFBFFFFEFFF;
-    y = 64'hC3FFC00000000000;
-    z = 64'h37F007FFFFFFFFBF;
-    ans = 64'hC41FBFFC07FFF01F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hB67629A54B42C449;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"764429\n");
+    	$fwrite(fp,"757961\n");
     end
-    x = 64'hC02DA3D0B1B2F367;
-    y = 64'hFFF0000000000000;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hF7F75C323BE19773;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'h3CAFFFFFFFFFFFC1;
+    ans = 64'h78275C323BE19772;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"765043\n");
+    	$fwrite(fp,"758267\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h43CFFFFFFFFFFF0F;
-    z = 64'hC80000FFFFFEFFFF;
-    ans = 64'hC80000FFFFFEFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h37EFFFFFEFFFDFFE;
+    ReadData3E = 64'h4F000004000003FF;
+    ans = 64'h4F000004000003FF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"765657\n");
+    	$fwrite(fp,"758573\n");
     end
-    x = 64'hBFDFFFFFFFFFFFF3;
-    y = 64'hFFF0000000000001;
-    z = 64'h3FDFFFFFFFFFF7FB;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h43DC3CB2A36EEDF9;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'hC40C3CB2A36EEDF7;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"766271\n");
+    	$fwrite(fp,"758879\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFF;
-    y = 64'h41F080FFFFFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFDEFDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC030007FFFFFFBFF;
+    ReadData2E = 64'h0011000001FFFFFE;
+    ReadData3E = 64'hC1FFFFDBFFFFFFFE;
+    ans = 64'hC1FFFFDBFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"766885\n");
+    	$fwrite(fp,"759185\n");
     end
-    x = 64'hBEC0080000003FFF;
-    y = 64'h39300003FFFFFFEF;
-    z = 64'hB80F865401D278F7;
-    ans = 64'hB817C72C01E95C73;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'h47FFFFFFFFFFAFFF;
+    ans = 64'h47FFFFFFFFFFAFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"767499\n");
+    	$fwrite(fp,"759491\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h0000000000000000;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h3FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBCAFF81FFFFFFFFE;
+    ReadData2E = 64'hFFDCF736D2BEB917;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h7C9CF015FC40DC26;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"768113\n");
+    	$fwrite(fp,"759797\n");
     end
-    x = 64'h000007FFFFFFFFFE;
-    y = 64'h3F6FFFFFFE01FFFE;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h00100007FFFFFF7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'hBFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"768727\n");
+    	$fwrite(fp,"760103\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h0000000000000001;
-    z = 64'hC0583D940632C786;
-    ans = 64'hC0583D940632C786;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC0600FFFFF7FFFFF;
+    ReadData2E = 64'h43D0000000007800;
+    ReadData3E = 64'h9326AC824E53D1EB;
+    ans = 64'hC4400FFFFF807877;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"769341\n");
+    	$fwrite(fp,"760409\n");
     end
-    x = 64'h7FEFFFFBFFFFFF80;
-    y = 64'h4026126760B56D8C;
-    z = 64'hD92BBFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"769955\n");
-    end
-    x = 64'hC1CFFFE000000040;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h401FFFFFFFFFFFFE;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3A523E7FF4DA7D44;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
     ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"770569\n");
+    	$fwrite(fp,"760715\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h4060000001000006;
-    z = 64'h4070001FFFFF7FFE;
-    ans = 64'h4070001FFFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h37E35FEF92C012CE;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'hB7FF7FFFFFF80000;
+    ans = 64'hBB335FEF92C012D1;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"771183\n");
+    	$fwrite(fp,"761021\n");
     end
-    x = 64'h548FFFFFC00FFFFE;
-    y = 64'h0010000000000000;
-    z = 64'h817B000000000000;
-    ans = 64'h14AFFFFFC00FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h40706E21CD654F01;
+    ReadData3E = 64'hBCA000000000083E;
+    ans = 64'h3D306621CD654EFC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"771797\n");
+    	$fwrite(fp,"761327\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h43C001000001FFFF;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'h407FFA000003FFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h00279DCB6C5826C9;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h83879DCB6C5826C8;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"772411\n");
+    	$fwrite(fp,"761633\n");
     end
-    x = 64'hC01FF7FFFFFEFFFF;
-    y = 64'hC3F2000000000FFE;
-    z = 64'h4800007FE0000000;
-    ans = 64'h4800007FE0000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC00000000FFFFFF7;
+    ReadData2E = 64'h3FEFFF87FFFFFFFE;
+    ReadData3E = 64'h3F68E540420AA576;
+    ans = 64'hBFFFF3157FDE8299;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"773025\n");
+    	$fwrite(fp,"761939\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h3FEFFFFFFFFFFFFE;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'hC1DFFFFFF0004000;
+    ans = 64'hC1DFFFFFF1004000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"762245\n");
+    end
+    ReadData1E = 64'hBEC7FE99C03ACAB9;
+    ReadData2E = 64'h33D00000FFFFDFFE;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"762551\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'hFC9FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"762857\n");
+    end
+    ReadData1E = 64'hC03FFEFFDFFFFFFF;
+    ReadData2E = 64'hC001000004000000;
+    ReadData3E = 64'h7FDFFFFFFFFFDFFE;
+    ans = 64'h7FDFFFFFFFFFDFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"763163\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h7FEFEF7FFFFFFFFF;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'h7CAFEF7FFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"763469\n");
+    end
+    ReadData1E = 64'h5A3FEB6457A93869;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hC1CE7828510813A0;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"763775\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFDFFFF7FFF7FFFE;
+    ReadData3E = 64'hC3C00000BFFFFFFF;
+    ans = 64'hC3C00000BFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"764081\n");
+    end
+    ReadData1E = 64'hC01F80000000000E;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"764387\n");
+    end
+    ReadData1E = 64'h4D4FEFFFFFFFF7FF;
+    ReadData2E = 64'hFFFFEFFFEFFFFFFE;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'hFFFFEFFFEFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"764693\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h8C60003FFFC00000;
+    ans = 64'hFCAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"764999\n");
+    end
+    ReadData1E = 64'hC01FFE0000000FFE;
+    ReadData2E = 64'hA3000007FFFFFFFD;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"765305\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'hFCAFFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"765611\n");
+    end
+    ReadData1E = 64'h40F000000FFE0000;
+    ReadData2E = 64'hBFBFBFEFFFFFFFFF;
+    ReadData3E = 64'h402904B537BDEEA5;
+    ans = 64'hC0BFB36DC520190A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"765917\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h434FFFFFC00003FF;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'h4017FFFFE0000200;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"766223\n");
+    end
+    ReadData1E = 64'hBFBD6817418AD7FF;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'hAAD0400001FFFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"766529\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FE00800007FFFFF;
+    ReadData3E = 64'hC1C0000038000000;
+    ans = 64'hC1C0000038000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"766835\n");
+    end
+    ReadData1E = 64'h434216727B125476;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"767141\n");
+    end
+    ReadData1E = 64'h8C0FFEFFFFFFFE00;
+    ReadData2E = 64'h4360000000FFFFEF;
+    ReadData3E = 64'h43F000003FFFFE00;
+    ans = 64'h43F000003FFFFE00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"767447\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h403FFFFFFFBDFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"767753\n");
+    end
+    ReadData1E = 64'h43CDFC0000000000;
+    ReadData2E = 64'h3800FE000D1AEA44;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBC9FFE027FF6770F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"768059\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"768365\n");
+    end
+    ReadData1E = 64'h3FEDFFC000000000;
+    ReadData2E = 64'hB680007C00000000;
+    ReadData3E = 64'hC1E001000FFFFFFF;
+    ans = 64'hC1E001000FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"768671\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData2E = 64'h380CE2920341D715;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hBFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"768977\n");
+    end
+    ReadData1E = 64'hC2201001FFFFFFFF;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'hD32FFFFFFF803FFE;
+    ans = 64'hD32FFFFFFF803FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"769283\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBF2400FFFFFFFFFE;
+    ReadData3E = 64'h3810008000100000;
+    ans = 64'hBBE400FFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"769589\n");
+    end
+    ReadData1E = 64'hBCA20FFFFFFFFFFE;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"769895\n");
+    end
+    ReadData1E = 64'hB810040000000400;
+    ReadData2E = 64'h3FD0004000000080;
+    ReadData3E = 64'h50C07FFFFFFBFFFF;
+    ans = 64'h50C07FFFFFFBFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"770201\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'hBF0FFFDFBFFFFFFE;
+    ans = 64'hBF0FFFDFBFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"770507\n");
+    end
+    ReadData1E = 64'h400000201FFFFFFF;
+    ReadData2E = 64'hC65FFBFEFFFFFFFE;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'hC66FFC3F37F5FDFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"770813\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"771119\n");
+    end
+    ReadData1E = 64'h400F00007FFFFFFF;
+    ReadData2E = 64'h41D000000004FFFF;
+    ReadData3E = 64'h381FFBFFFFBFFFFF;
+    ans = 64'h41EF00008009AFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"771425\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFCFFFEFEFFFFFFE;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
     ans = 64'h3FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"773639\n");
+    	$fwrite(fp,"771731\n");
     end
-    x = 64'hBFEFFFFFFFDBFFFF;
-    y = 64'hB7FFFFFFFFF7FFF7;
-    z = 64'h0000000000000000;
-    ans = 64'h37FFFFFFFFD3FFF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h4020000007FFFC00;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'hC00DBEC4D86AAF0A;
+    ans = 64'hC00DBEC4D86AAF0A;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"774253\n");
+    	$fwrite(fp,"772037\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h3CA0000000000000;
-    z = 64'hC49FF7FFFE000000;
-    ans = 64'hC49FF7FFFE000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBF3FFFFFFFEFFDFF;
+    ReadData3E = 64'hBFDFFFFFF00003FF;
+    ans = 64'hBFDFFFFFF00003FF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"774867\n");
+    	$fwrite(fp,"772343\n");
     end
-    x = 64'h51E7FFFFFFFFFF7F;
-    y = 64'h40129211363ADFB4;
-    z = 64'hCB697B092581A9BA;
-    ans = 64'h520BDB19D1584EF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h801FFFFFEBFFFFFE;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"775481\n");
+    	$fwrite(fp,"772649\n");
     end
-    x = 64'hC074007FFFFFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h4010000000000000;
-    ans = 64'h400FFFFFFFFFFF60;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hDC1FFBFBFFFFFFFE;
+    ReadData2E = 64'h47FFFFFFF4000000;
+    ReadData3E = 64'hBF3FFDFFFFFFFFFF;
+    ans = 64'hE42FFBFBF401817E;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"776095\n");
+    	$fwrite(fp,"772955\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h48000000000000EF;
-    z = 64'hA20003FFFF800000;
-    ans = 64'h44C00000000000EE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'hC1E63CFF38491175;
+    ans = 64'hC1E63CFF38491175;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"776709\n");
+    	$fwrite(fp,"773261\n");
     end
-    x = 64'h40B0000000003FF8;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h438FFEFFFFFFFFDF;
-    ans = 64'h438FFEFFFFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3800A00000000000;
+    ReadData2E = 64'hBFAFFFFF003FFFFF;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'hB7C09FFF7B213FFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"777323\n");
+    	$fwrite(fp,"773567\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC7F9D14ED895890F;
-    z = 64'hBFD0000000000000;
-    ans = 64'hC4B9D14ED895890D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"777937\n");
+    	$fwrite(fp,"773873\n");
     end
-    x = 64'h801000000007FFFF;
-    y = 64'hBFD36A9BB1F93547;
-    z = 64'h405000000000006F;
-    ans = 64'h405000000000006F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"778551\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"779165\n");
-    end
-    x = 64'h002FFEF7FFFFFFFF;
-    y = 64'hC08FFFFE0FFFFFFE;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"779779\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h402FFF801FFFFFFE;
-    ans = 64'h402FFF801FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"780393\n");
-    end
-    x = 64'hBEC02000001FFFFF;
-    y = 64'hCC5000DFFFFFFFFF;
-    z = 64'hB7F0010000000040;
-    ans = 64'h4B2020E1C02001BE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"781007\n");
-    end
-    x = 64'h3CA000000FFF0000;
-    y = 64'h3FE0000000000001;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"781621\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h403FFFFFBFFFEFFE;
-    z = 64'h37ED46FC2B0023A2;
-    ans = 64'h3CFFFFFFBFFFEFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"782235\n");
-    end
-    x = 64'hB7E9EFD68B497421;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h3E6000000000040E;
-    ans = 64'h3E6000000000040E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"782849\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h000266016A39E777;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"783463\n");
-    end
-    x = 64'h37F95059156CD4C4;
-    y = 64'hC3F01DFFFFFFFFFF;
-    z = 64'hC7F0002000000004;
-    ans = 64'hC7F0002000000004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"784077\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h3FF0000000000001;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"784691\n");
-    end
-    x = 64'h80070847320BC888;
-    y = 64'h7CE47DBA0F14EAF5;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"785305\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hB7F4FECA1F205474;
-    ans = 64'h3CBFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"785919\n");
-    end
-    x = 64'hC03FFE001FFFFFFF;
-    y = 64'hC5DCEA96744E1936;
-    z = 64'h43C0000003EFFFFF;
-    ans = 64'h462CE8C7E7D1AAC8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"786533\n");
-    end
-    x = 64'hBFD7FFFFFFBFFFFF;
-    y = 64'h4000000000000000;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h3FF4000000200000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"787147\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC5CE77F1E2F669DB;
-    z = 64'h49C3FFFFFFFDFFFF;
-    ans = 64'h49C3FFFFFFFDFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"787761\n");
-    end
-    x = 64'h3D1FFFFFFFFFFFF5;
-    y = 64'h4000000000000001;
-    z = 64'h32F000007FFFFFFF;
-    ans = 64'h3D2FFFFFFFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"788375\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC3C0FFFFFFFFFFFF;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'hC080FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"788989\n");
-    end
-    x = 64'h40D00001FFBFFFFF;
-    y = 64'h66B7849965C4EBF6;
-    z = 64'hBCC000004000007E;
-    ans = 64'h6797849C55FA0648;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"789603\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h4010000000000000;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CD3FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"790217\n");
-    end
-    x = 64'h761FAA6A41261C23;
-    y = 64'h477FFF8000000002;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'h7DAFA9EB977D178D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"790831\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h4010000000000001;
-    z = 64'h4039A83A2B1F9F06;
-    ans = 64'h4039A83A2B1F9F06;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"791445\n");
-    end
-    x = 64'h3CAA3DE7B7AA7C1C;
-    y = 64'h3FEFFFFFFF8001FF;
-    z = 64'h43F00000000DFFFE;
-    ans = 64'h43F00000000DFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"792059\n");
-    end
-    x = 64'h6A9FFFFF07FFFFFF;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h6ACFFFFF07FFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"792673\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h36DBC55BED797727;
-    z = 64'hC10EF56A7E932EFD;
-    ans = 64'hC10EF56A7E932EFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"793287\n");
-    end
-    x = 64'hB809C1DDC84B5E09;
-    y = 64'h4340000000000000;
-    z = 64'hC72FFDF7FFFFFFFF;
-    ans = 64'hC72FFDF7FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"793901\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC51574C4CCC1F217;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hC1D574C4CCC1F216;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"794515\n");
-    end
-    x = 64'hC34000007FFFEFFF;
-    y = 64'hC800000000007FFA;
-    z = 64'hDB9FFFFFFF6FFFFE;
-    ans = 64'hDB9FFFFFFF6FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"795129\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"795743\n");
-    end
-    x = 64'hC02F000003FFFFFF;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"796357\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h7FE0000000000000;
-    z = 64'h3F2FFDFFFFFFFF80;
-    ans = 64'h7C9FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"796971\n");
-    end
-    x = 64'hB7F07FFFFFFFFFFC;
-    y = 64'h7FDFFFFFFFFF7C00;
-    z = 64'hC03FFFFFC0000003;
-    ans = 64'hF7E07FFFFFFFBBEC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"797585\n");
-    end
-    x = 64'h801FFFFBFEFFFFFE;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h3FE0000000000000;
-    ans = 64'hC01DFFFBFEFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"798199\n");
-    end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hBFDFEFFFFFFFEFFF;
-    z = 64'h43A0043FFFFFFFFE;
-    ans = 64'h43A0043FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"798813\n");
-    end
-    x = 64'hC017A0FB0E9F66C3;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hFFDFEFFFFFFFFFDE;
+    ReadData1E = 64'h7D00000001FFFBFE;
+    ReadData2E = 64'hC3C0000001000004;
+    ReadData3E = 64'hBFC0000000083FFE;
     ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"799427\n");
+    	$fwrite(fp,"774179\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC01FFFBFBFFFFFFF;
-    z = 64'h8000000000000000;
-    ans = 64'hBCDFFFBFBFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC0156543FCA323DC;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hBFE000000000000B;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"800041\n");
+    	$fwrite(fp,"774485\n");
     end
-    x = 64'hBFBFFDC000000000;
-    y = 64'h37F003FFFFFFFEFE;
-    z = 64'hC093287BC3456222;
-    ans = 64'hC093287BC3456222;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBF200001001FFFFF;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'hBD501BFFFFFFFFFF;
+    ans = 64'hBD501BFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"800655\n");
+    	$fwrite(fp,"774791\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h0010000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h47EFFF80007FFFFF;
+    ReadData3E = 64'h3FEFFFFFEFFF0000;
+    ans = 64'h44AFFF80007FFFFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"801269\n");
+    	$fwrite(fp,"775097\n");
     end
-    x = 64'hC060000080000400;
-    y = 64'hBFD000000100000E;
-    z = 64'hC010000000000001;
-    ans = 64'h403C00010200082C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC02FFFFFFFF7FFEF;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"801883\n");
+    	$fwrite(fp,"775403\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h41C0000000000FE0;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFEC0000000007FF;
+    ReadData2E = 64'h000F9D0DF8DF20DF;
+    ReadData3E = 64'h32AFFFFF6FFFFFFF;
+    ans = 64'h32AFFFFF6FFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"802497\n");
+    	$fwrite(fp,"775709\n");
     end
-    x = 64'hC7EFC000007FFFFF;
-    y = 64'h3FBFFFFFFFFFE7FE;
-    z = 64'h3FEBA884A0712B77;
-    ans = 64'hC7BFC000007FE82D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'hBFD367D06C6CD192;
+    ans = 64'hBFD367D06C6CD192;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"803111\n");
+    	$fwrite(fp,"776015\n");
     end
-    x = 64'h8022424C23A46355;
-    y = 64'h8000000000000001;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB2EFFFFFFFBFFFFF;
+    ReadData2E = 64'h41E0007FC0000000;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'hB4E0007FBFDFFF00;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"803725\n");
+    	$fwrite(fp,"776321\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hD4DFFFF800800000;
-    z = 64'h401FFC7FFFFFFFFE;
-    ans = 64'hD19FFFF8007FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"804339\n");
+    	$fwrite(fp,"776627\n");
     end
-    x = 64'h3FEA91C55BA6D318;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h38A3B6C3AD39060C;
-    ans = 64'h38A3B6C3AD39060C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hE160010000000080;
+    ReadData2E = 64'h20E1FFFFFFFFFFFF;
+    ReadData3E = 64'h293DF7FFFFFFFFFE;
+    ans = 64'hC25201200000008F;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"804953\n");
+    	$fwrite(fp,"776933\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hBFDFFFDFFFFFFFF0;
-    z = 64'h7FF0000000000001;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hFFE4F8119C381900;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'hFCA4F8119C3818FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"777239\n");
+    end
+    ReadData1E = 64'h40192DFAA3A08E50;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'hC7E000800003FFFF;
+    ans = 64'hC7E000800003FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"777545\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FFFF80000FFFFFF;
+    ReadData3E = 64'hC790000000000006;
+    ans = 64'hC790000000000006;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"777851\n");
+    end
+    ReadData1E = 64'h43CFBFFFFFFBFFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h408FDFFFFFFBFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"778157\n");
+    end
+    ReadData1E = 64'h43EFFFF7FFFF0000;
+    ReadData2E = 64'h002000008000001F;
+    ReadData3E = 64'h409FFFF7BFFFFFFF;
+    ans = 64'h409FFFF7BFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"778463\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'hBCAFFFFFFFE00000;
+    ans = 64'hBCA7FFFFFFE00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"778769\n");
+    end
+    ReadData1E = 64'h480040000000001F;
+    ReadData2E = 64'hC3EFFFFFFFFFF03F;
+    ReadData3E = 64'h7FF0000000000001;
     ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"805567\n");
+    	$fwrite(fp,"779075\n");
     end
-    x = 64'h381FDFFFFFFFFC00;
-    y = 64'h3E400000400FFFFF;
-    z = 64'hC03605C500F49014;
-    ans = 64'hC03605C500F49014;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"806181\n");
+    	$fwrite(fp,"779381\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h8010000000000001;
-    z = 64'h0000000000000001;
-    ans = 64'h0000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC5B81A8A748009FF;
+    ReadData2E = 64'h40100000000000C0;
+    ReadData3E = 64'hC0F0001FFFFFFEFE;
+    ans = 64'hC5D81A8A74800B20;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"806795\n");
+    	$fwrite(fp,"779687\n");
     end
-    x = 64'hC0E0000000000401;
-    y = 64'h80100000083FFFFE;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h43CEFFFFFC000000;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'h408EFFFFFBFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"807409\n");
+    	$fwrite(fp,"779993\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h408FFFE0000003FF;
-    ans = 64'h408FFFE0000003FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hE337B88BE495EEA7;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'h400FFFFFF7EFFFFF;
+    ans = 64'hE327B88BE495EEA6;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"808023\n");
+    	$fwrite(fp,"780299\n");
     end
-    x = 64'h3C4000007FFFFFFB;
-    y = 64'h3FB0020000080000;
-    z = 64'hC11FF7FFFFFFFFF0;
-    ans = 64'hC11FF7FFFFFFFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h16C929AB0692347E;
+    ReadData3E = 64'hC02382DEFC30F29B;
+    ans = 64'hC02382DEFC30F29B;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"808637\n");
+    	$fwrite(fp,"780605\n");
     end
-    x = 64'hC7E00000000F7FFE;
-    y = 64'hBCA0000000000000;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h44900000000F7FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h40AFFFBFFFFFFFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'h409FF7BFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"809251\n");
+    	$fwrite(fp,"780911\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h3FEFFFFFFFFFFEFC;
-    z = 64'hFFD00000043FFFFF;
-    ans = 64'hFFD00000043FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBF0FFFF8000000FF;
+    ReadData2E = 64'hC1C040000007FFFF;
+    ReadData3E = 64'h40F01FFFFFFFFF7F;
+    ans = 64'h40F83FFDF803FFBE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"809865\n");
+    	$fwrite(fp,"781217\n");
     end
-    x = 64'hC800080000000002;
-    y = 64'hBCA0000000000001;
-    z = 64'h00000000000000FB;
-    ans = 64'h44B0080000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'hC1FEFFFFFFF7FFFE;
+    ans = 64'hC1FEFFFFFFF7FFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"810479\n");
+    	$fwrite(fp,"781523\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h47F00000FFBFFFFE;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC10FFF8000000000;
+    ReadData2E = 64'h2D300000003FFFC0;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"811093\n");
+    	$fwrite(fp,"781829\n");
     end
-    x = 64'hBFF004000003FFFF;
-    y = 64'h84F9917D0C96A324;
-    z = 64'hB450100000080000;
-    ans = 64'hB450100000080000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h400FFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"811707\n");
+    	$fwrite(fp,"782135\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3EDFFFFE0000000E;
+    ReadData2E = 64'h3FE0002FFFFFFFFF;
+    ReadData3E = 64'h41D01FFEFFFFFFFE;
+    ans = 64'h41D01FFF0000000E;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"812321\n");
+    	$fwrite(fp,"782441\n");
     end
-    x = 64'h41FFFFFFFEFFFDFF;
-    y = 64'h0DEFFFFFFF007FFF;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC3FFFFF100000000;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'hC0BFFFF0FFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"812935\n");
+    	$fwrite(fp,"782747\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hBFD0000000000001;
-    z = 64'h4030808000000000;
-    ans = 64'h4030808000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB810000000041000;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'h49660E2E11B09A23;
+    ans = 64'h49660E2E11B09A23;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"813549\n");
+    	$fwrite(fp,"783053\n");
     end
-    x = 64'hC0300000000003EF;
-    y = 64'h408FFFBFFFEFFFFF;
-    z = 64'hBDAFFFE01FFFFFFE;
-    ans = 64'hC0CFFFBFFFF007E5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h43D010000000007F;
+    ReadData3E = 64'hE2C0000010000FFF;
+    ans = 64'hE2C0000010000FFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"814163\n");
+    	$fwrite(fp,"783359\n");
     end
-    x = 64'h4173847C57956A54;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'hC163847C57956A53;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFC1FEFFFFFFFFFF;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h3FEB804000000002;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"814777\n");
+    	$fwrite(fp,"783665\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hFFF0000006000000;
-    z = 64'h377FFFFF80001FFF;
-    ans = 64'hFFF8000006000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC15FFFFFDFFFFFBF;
+    ReadData2E = 64'h37E003FFFF7FFFFE;
+    ReadData3E = 64'h3FA000000BFFFFFE;
+    ans = 64'h3FA000000BFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"815391\n");
+    	$fwrite(fp,"783971\n");
     end
-    x = 64'h3FEFAFFFFFFFFFFE;
-    y = 64'hBFE0000000000000;
-    z = 64'h40B000007FFFDFFE;
-    ans = 64'h40AFFF037FFFBFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FCFFFF7FEFFFFFF;
+    ans = 64'h3FCFFFF7FF000007;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"816005\n");
+    	$fwrite(fp,"784277\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC7EFFFFFFFFFEFFF;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'hC4AFFFFF7FFFEFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC7EE008000000000;
+    ReadData2E = 64'h403FFFFFFFF7BFFF;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'hC83E007FFFF843DE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"816619\n");
+    	$fwrite(fp,"784583\n");
     end
-    x = 64'h3F1AF153D63208C5;
-    y = 64'h41CFEDD90920FE45;
-    z = 64'hC3D0000000000820;
-    ans = 64'hC3D00000000007B4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hBFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"817233\n");
+    	$fwrite(fp,"784889\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFE;
+    ReadData1E = 64'hB7FC6D6EAD2BD6AB;
+    ReadData2E = 64'hC7EFFFFFFFFF87FE;
+    ReadData3E = 64'h438FFFEE00000000;
+    ans = 64'h438FFFEE00000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"785195\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3800FFFFFFFFFF7E;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h34C0FFFFFFFFFF7D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"785501\n");
+    end
+    ReadData1E = 64'hFFE00000200000FF;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'hC362D940E64F79A5;
+    ans = 64'hFFE00000200000FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"785807\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h001F7FFFFFFEFFFF;
+    ReadData3E = 64'hFFF8EFD2FE79C24A;
+    ans = 64'hFFF8EFD2FE79C24A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"786113\n");
+    end
+    ReadData1E = 64'h40810000001FFFFE;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'h4080F800001FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"786419\n");
+    end
+    ReadData1E = 64'hC007FFFFFFFFC000;
+    ReadData2E = 64'h401FC00000080000;
+    ReadData3E = 64'hC3C01FFFFFFFFFFF;
+    ans = 64'hC3C01FFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"786725\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h43EFFFFFFFEFDFFE;
+    ans = 64'h43EFFFFFFFEFDFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"787031\n");
+    end
+    ReadData1E = 64'h3FF0800000000003;
+    ReadData2E = 64'h47FA61529E587B8B;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'h47FB345D334B3F6C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"787337\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h3FF0000000000003;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"787643\n");
+    end
+    ReadData1E = 64'h3E4124E67B52FD98;
+    ReadData2E = 64'hC00FFF0000000FFE;
+    ReadData3E = 64'h8727490D6F398EA1;
+    ans = 64'hBE61245D541F2B91;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"787949\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h804FFFF7FFFFFFEE;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'h800000000000000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"788255\n");
+    end
+    ReadData1E = 64'hBF9526E7BD8A1F46;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'h480FFFDFFFFFFFDF;
+    ans = 64'h480FFFDFFFFFFFDF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"788561\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h381020000007FFFE;
+    ReadData3E = 64'h37E00003FFF7FFFF;
+    ans = 64'h37E00003FFF80007;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"788867\n");
+    end
+    ReadData1E = 64'hFFDFF7FFFFFFFBFF;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'hFFEFF7FFFFFFFC01;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"789173\n");
+    end
+    ReadData1E = 64'h003C97950DCA0015;
+    ReadData2E = 64'hEFACB38DCC424DA6;
+    ReadData3E = 64'h278003FFFFEFFFFE;
+    ans = 64'hAFF9A51108403B01;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"789479\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'hC95F800100000000;
+    ans = 64'hC95F800100000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"789785\n");
+    end
+    ReadData1E = 64'h7FF0EFBB42DBF4E3;
+    ReadData2E = 64'h2255FFFFFFFFFFFF;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h7FF8EFBB42DBF4E3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"790091\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hBFEFFFFFFFFFFFF7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"790397\n");
+    end
+    ReadData1E = 64'h46F342BC1CEBE027;
+    ReadData2E = 64'hC3D6C59A9D585605;
+    ReadData3E = 64'h802DFFFFFFFFBFFE;
+    ans = 64'hCADB69A273A42F3F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"790703\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC00FFDFFFFFFFFFF;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"791009\n");
+    end
+    ReadData1E = 64'h30B00000010FFFFF;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'hC7F903C3D334F340;
+    ans = 64'hC7F903C3D334F340;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"791315\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3CAFC89A50DE63CA;
+    ReadData3E = 64'hC04C000007FFFFFF;
+    ans = 64'hC04C000007FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"791621\n");
+    end
+    ReadData1E = 64'hC3C0000000BFFFFE;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'hC3E0000000BFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"791927\n");
+    end
+    ReadData1E = 64'hBF8F80000000007F;
+    ReadData2E = 64'h000000013FFFFFFE;
+    ReadData3E = 64'hC3DFFFF803FFFFFF;
+    ans = 64'hC3DFFFF803FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"792233\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'hB80FFFF00007FFFF;
+    ans = 64'h3CD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"792539\n");
+    end
+    ReadData1E = 64'hC00000000001003E;
+    ReadData2E = 64'h402CDC4C5AFCC35F;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hC0406E262D7F48CA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"792845\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h3FE000000000000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"793151\n");
+    end
+    ReadData1E = 64'h43CFFFFC0003FFFF;
+    ReadData2E = 64'h8020FFFFFFFFFFFB;
+    ReadData3E = 64'h467691F27D3EA690;
+    ans = 64'h467691F27D3EA690;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"793457\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC96004000003FFFF;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
     ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"817847\n");
+    	$fwrite(fp,"793763\n");
     end
-    x = 64'h3FF000010003FFFE;
-    y = 64'h40D000000DFFFFFF;
-    z = 64'hBFF0000000000000;
-    ans = 64'h40CFFF821C0801BA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFFFC7FFFFFFFFFF;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FEFFFFFFF7FFFE0;
+    ans = 64'hFFFFC7FFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"818461\n");
+    	$fwrite(fp,"794069\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hBFF0000000000000;
-    z = 64'hEB9C3D16BF65A760;
-    ans = 64'hEB9C3D16BF65A760;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hB7E1000FFFFFFFFE;
+    ReadData3E = 64'hC34FFFFFFDFFFFFE;
+    ans = 64'hC34FFFFFFDFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"819075\n");
+    	$fwrite(fp,"794375\n");
     end
-    x = 64'h4341BC45DB03D622;
-    y = 64'h480FFFFFFFBFFFFA;
-    z = 64'h80000DFFFFFFFFFE;
-    ans = 64'h4B61BC45DAE05D93;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h406FFFFFF7FFF7FE;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'h43BFFFFFF7FFF7FE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"819689\n");
+    	$fwrite(fp,"794681\n");
     end
-    x = 64'hBE53168DFE97BEEE;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h0010000000000000;
-    ans = 64'h3E63168DFE97BEED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFD0002000000040;
+    ReadData2E = 64'hC03C96F971286B1E;
+    ReadData3E = 64'h41EFFC0200000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"820303\n");
+    	$fwrite(fp,"794987\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h402000000001FFFB;
-    z = 64'h40400000007FFFFA;
-    ans = 64'h40400000007FFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'h420000040000FFFF;
+    ans = 64'h420000040010FFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"820917\n");
+    	$fwrite(fp,"795293\n");
     end
-    x = 64'h7FFD8B8508E0B4F6;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h381FFFFFFFFF7FFF;
-    ans = 64'h7FFD8B8508E0B4F6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h8020010001FFFFFE;
+    ReadData2E = 64'h525FFFFEFFFFF000;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"821531\n");
+    	$fwrite(fp,"795599\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h49F000000003FEFE;
-    z = 64'h4340000000000000;
-    ans = 64'h46B000000003FEFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'h3FFC000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"822145\n");
+    	$fwrite(fp,"795905\n");
     end
-    x = 64'h002FFFE0000000FF;
-    y = 64'h629000007FFDFFFF;
-    z = 64'hC1E002FFFFFFFFFF;
-    ans = 64'hC1E002FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h7FFFFC03FFFFFFFF;
+    ReadData2E = 64'hB7EFFFFFEEFFFFFF;
+    ReadData3E = 64'h00100003FFFF7FFF;
+    ans = 64'h7FFFFC03FFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"822759\n");
+    	$fwrite(fp,"796211\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC000000000000001;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hCD7FFFFFFFFDFFF6;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"823373\n");
+    	$fwrite(fp,"796517\n");
     end
-    x = 64'h9BF080000001FFFF;
-    y = 64'hC1E3B08DE8F3BD01;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hDB40010002000000;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FC35D556174AFCD;
+    ans = 64'hDEA0010001FFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"823987\n");
+    	$fwrite(fp,"796823\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hC01000000020007F;
-    ans = 64'hC010000000200080;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFD7BFFFFFFFFFFF;
+    ReadData3E = 64'h806852766CBEC085;
+    ans = 64'hBC97BFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"824601\n");
+    	$fwrite(fp,"797129\n");
     end
-    x = 64'hBFAFFFFFFC03FFFE;
-    y = 64'h3CA00003FFFEFFFE;
-    z = 64'h3CA0040000002000;
-    ans = 64'h3C9E07FF80402010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFDFFEFFFFF;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h433FFFFDFFEFFFFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"825215\n");
+    	$fwrite(fp,"797435\n");
     end
-    x = 64'hBFAFFFFFFFFC03FF;
-    y = 64'hC010000000000001;
-    z = 64'h0000000000000001;
-    ans = 64'h3FCFFFFFFFFC0401;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB4B6E07873102932;
+    ReadData2E = 64'h434FF87FFFFFFFFF;
+    ReadData3E = 64'h47E34D80C103EAA3;
+    ans = 64'h47E34D80C103EAA3;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"825829\n");
+    	$fwrite(fp,"797741\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hBFCFFE0000FFFFFF;
-    z = 64'h3ED001FFFFFFDFFF;
-    ans = 64'h3ED001FFFFFEE00F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'h43400FFFFFF80000;
+    ans = 64'h7C9FFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"826443\n");
+    	$fwrite(fp,"798047\n");
     end
-    x = 64'h3232BD6AC09064AA;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hB8000000001FFF80;
-    ans = 64'hB8000000001FFF80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h41300010000FFFFF;
+    ReadData2E = 64'hBFAFFFFFDFFFFF80;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hC0F0001FF00FEFBF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"827057\n");
+    	$fwrite(fp,"798353\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC00FFFFFFFFFFF08;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'h7CA0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"827671\n");
+    	$fwrite(fp,"798659\n");
     end
-    x = 64'hF9000FFFFFFEFFFF;
-    y = 64'hC00FFFFFD7FFFFFF;
-    z = 64'h4FEF54534F810F43;
-    ans = 64'h79200FFFEBEAFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC1E85FEE97A05DE1;
+    ReadData2E = 64'h43C4000000080000;
+    ReadData3E = 64'hC1CFF0B2863E46AD;
+    ans = 64'hC5BE77EA3D94A551;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"828285\n");
+    	$fwrite(fp,"798965\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC340000000000000;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h4000001FFFFFFFFF;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC340000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"828899\n");
+    	$fwrite(fp,"799271\n");
     end
-    x = 64'hBF0B677CE222C3C4;
-    y = 64'h5B5007FFFFFFEFFF;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hDA6B7530A093B9BD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h44BC001000000000;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h49E9A8F935ADEB66;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"829513\n");
+    	$fwrite(fp,"799577\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hC04C8260C328A10C;
-    ans = 64'hC04E8260C328A10C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h416AA0B165976F71;
+    ReadData3E = 64'hBF0010000003FFFE;
+    ans = 64'hBF000F957D3E69A0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"830127\n");
+    	$fwrite(fp,"799883\n");
     end
-    x = 64'hC32351DA9045BE0B;
-    y = 64'h83FFFFFFFBFFFFFF;
-    z = 64'h37FFFFFFDFFF8000;
-    ans = 64'h37FFFFFFDFFF8000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h80003FFFFFE00000;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'hBFAFFFFFEFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"830741\n");
+    	$fwrite(fp,"800189\n");
     end
-    x = 64'h3E298A451963779F;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC1DFFEFFFFFFFEFF;
+    ReadData2E = 64'h43C003FEFFFFFFFF;
+    ReadData3E = 64'hFB4FFFFF800000FF;
+    ans = 64'hFB4FFFFF800000FF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"831355\n");
+    	$fwrite(fp,"800495\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC3C1127530CEDD0B;
-    z = 64'h41CFFFFFFFFFFFA0;
-    ans = 64'h41CFFFFEEED8AC93;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hAD5080B9606E81BA;
+    ans = 64'h7CAFFFFFFFFFFFFC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"831969\n");
+    	$fwrite(fp,"800801\n");
     end
-    x = 64'h41C000000040001F;
-    y = 64'hFFE0000000000001;
-    z = 64'h3A297E3D1F64A3F4;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h37F000000000DFFF;
+    ReadData2E = 64'h3F8A7CA782E53728;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h3FE0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"832583\n");
+    	$fwrite(fp,"801107\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hC3FFFE1FFFFFFFFF;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'hC0BFFA1FFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"833197\n");
+    	$fwrite(fp,"801413\n");
     end
-    x = 64'h58EFFFFEFFEFFFFF;
-    y = 64'h3FFFFFFFFFF00000;
-    z = 64'hBFE7FFFFFBFFFFFF;
-    ans = 64'h58FFFFFEFFE00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB5FFFFFFF0000003;
+    ReadData2E = 64'hBFB0000000000900;
+    ReadData3E = 64'h40B0000000000F7F;
+    ans = 64'h40B0000000000F7F;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"833811\n");
+    	$fwrite(fp,"801719\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hFCAFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hA81FFFF00000007F;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h401FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"834425\n");
+    	$fwrite(fp,"802025\n");
     end
-    x = 64'h41DFEFFFFFBFFFFF;
-    y = 64'hBCAFF00000001FFF;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBE9FE00800003FEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hD5A00009FFFFFFFF;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'h364FFFFFFC3FFFFF;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"835039\n");
+    	$fwrite(fp,"802331\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'hFFF0000000000001;
-    z = 64'h7FF0000003FFE000;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FAFFFFF003FFFFF;
+    ReadData3E = 64'h41DE7402306C1129;
+    ans = 64'h41DE7402306C1129;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"835653\n");
+    	$fwrite(fp,"802637\n");
     end
-    x = 64'hFFE9564FB99A2A23;
-    y = 64'h3FEFFFFFF7FFC000;
-    z = 64'h3F63E56EDFA19196;
-    ans = 64'hFFE9564FB3446388;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h2A3FFFFFF8000000;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"836267\n");
+    	$fwrite(fp,"802943\n");
     end
-    x = 64'hB970001FFFFEFFFE;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC00007FFFFFFFFFF;
+    ReadData2E = 64'hBFE00077FFFFFFFE;
+    ReadData3E = 64'h400E0000007FFFFE;
+    ans = 64'h4013021E0F3FFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"836881\n");
+    	$fwrite(fp,"803249\n");
     end
-    x = 64'h3CAFFFFFFFFFFFFE;
-    y = 64'h801A6DCDC520170C;
-    z = 64'h37E00004000000FE;
-    ans = 64'h37E00004000000FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hBE8000003FFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"837495\n");
+    	$fwrite(fp,"803555\n");
     end
-    x = 64'h4380003FFFDFFFFF;
-    y = 64'h0000000000000000;
-    z = 64'hC1CFFFFFFFFFFDEF;
-    ans = 64'hC1CFFFFFFFFFFDEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFBFFFE00007FFFF;
+    ReadData2E = 64'hBFEFFFFFFEBFFFFE;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFD80008004DFFB0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"838109\n");
+    	$fwrite(fp,"803861\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h3FCFFFFBF0000000;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h40007FFFEFBFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'h000FFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"838723\n");
+    	$fwrite(fp,"804167\n");
     end
-    x = 64'h441FFFFFFFFFFFF5;
-    y = 64'hC80FF800001FFFFE;
-    z = 64'h47FA1083AB1A334C;
-    ans = 64'hCC3FF800001FFFF3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC96000000FFFFFDE;
+    ReadData2E = 64'h31D03FFFFFFF8000;
+    ReadData3E = 64'hC1C87E0A0FF31A23;
+    ans = 64'hC1C87E0A0FF31A23;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"839337\n");
+    	$fwrite(fp,"804473\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hC00FFFFFFFFFFFFE;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3345D50CBBB891A1;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
     ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"839951\n");
+    	$fwrite(fp,"804779\n");
     end
-    x = 64'h45C000000080001E;
-    y = 64'h4340007FFE000000;
-    z = 64'hBCA0000000000000;
-    ans = 64'h4910007FFE80041E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC7F0B2F9A4CB116D;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'h9C019C696C0DD16A;
+    ans = 64'h9C019C696C0DD16A;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"840565\n");
+    	$fwrite(fp,"805085\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h0010000000000000;
-    z = 64'hBAD00000003FEFFF;
-    ans = 64'hBAD00000003FEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hB7F00000007FFE00;
+    ReadData3E = 64'hBEAFF7FFF0000000;
+    ans = 64'hBEAFF7FFF0000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"841179\n");
+    	$fwrite(fp,"805391\n");
     end
-    x = 64'h0000010000000400;
-    y = 64'h37E083FFFFFFFFFF;
-    z = 64'hC7EFFFFFFF80FFFE;
-    ans = 64'hC7EFFFFFFF80FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hCDA521B1B27F8608;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"841793\n");
+    	$fwrite(fp,"805697\n");
     end
-    x = 64'hC3D0001FFDFFFFFF;
-    y = 64'h0010000000000001;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h41D3F2F4802615C5;
+    ReadData2E = 64'hC00FFFF7FFDFFFFE;
+    ReadData3E = 64'h40AFFFFF80000020;
+    ans = 64'hC1F3F2EE835506C6;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"842407\n");
+    	$fwrite(fp,"806003\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hBFD0000000000140;
-    z = 64'hC1D1CA517F76AEDD;
-    ans = 64'hC1D1CA517F7AAEDD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'hC07FFFFFFF7FFFFE;
+    ans = 64'hC07FFFFFFF7FFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"843021\n");
+    	$fwrite(fp,"806309\n");
     end
-    x = 64'hC7FFFFFFFFFE001E;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h38507FFFFFFF7FFE;
-    ans = 64'h38507FFFFFFF7FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h4051FFFFFFFFF7FF;
+    ReadData2E = 64'h3FF80A0A70A9D9F4;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h405B0B4BBEBF092C;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"843635\n");
+    	$fwrite(fp,"806615\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hB80FFFFF000001FF;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h8000000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"844249\n");
+    	$fwrite(fp,"806921\n");
     end
-    x = 64'hB7FF0007FFFFFFFE;
-    y = 64'h401FE0000000007F;
-    z = 64'h41D003FFFFFFFFFD;
-    ans = 64'h41D003FFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h40EFFFFFCFFFFFFF;
+    ReadData2E = 64'hBF46B20A5AF687D4;
+    ReadData3E = 64'h4010403FFFFFFFFE;
+    ans = 64'hC044AA0238EB784B;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"844863\n");
+    	$fwrite(fp,"807227\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h3CA0000000000001;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h4B0F8001FFFFFFFF;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'h47CF8001FFFFFFFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"807533\n");
+    end
+    ReadData1E = 64'h405000FFFFFF7FFE;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'h3FBFE00100000000;
+    ans = 64'h3FBFE00100000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"807839\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h402E000001FFFFFF;
+    ReadData3E = 64'hC1DFFFFBFFFFBFFF;
+    ans = 64'hC1DFFFFBFFFFBFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"808145\n");
+    end
+    ReadData1E = 64'hC0F0001FFFFFFEFF;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"808451\n");
+    end
+    ReadData1E = 64'hC02409224A572D98;
+    ReadData2E = 64'hC06FFFFFE0020000;
+    ReadData3E = 64'h3FFFFFFFF007FFFF;
+    ans = 64'h40A40D22364D4CE0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"808757\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h4B87A4A7FDD82AE3;
+    ans = 64'h4B87A4A7FDD82AE3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"809063\n");
+    end
+    ReadData1E = 64'hC0F0001FFFFFFFFB;
+    ReadData2E = 64'hC089DB2B2EDEB592;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'h4189DB5EE5351347;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"809369\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"809675\n");
+    end
+    ReadData1E = 64'h4A6040000000000F;
+    ReadData2E = 64'hC0300100000003FF;
+    ReadData3E = 64'hC3E0000000000000;
+    ans = 64'hCAA041040000041E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"809981\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h7FE000000FFFFFFF;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'h7CA000000FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"810287\n");
+    end
+    ReadData1E = 64'h41FFF1070335C8D9;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'hBFA0DC2898783816;
+    ans = 64'hBFA0DC48897F3B4C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"810593\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3D93E99A04CEC718;
+    ReadData3E = 64'hC3DFFDFFDFFFFFFF;
+    ans = 64'hC3DFFDFFDFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"810899\n");
+    end
+    ReadData1E = 64'hC1F14340A63773D7;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"811205\n");
+    end
+    ReadData1E = 64'hA32C85A44ACBA581;
+    ReadData2E = 64'h41F7FFFFFFFFFFDE;
+    ReadData3E = 64'h43CFFFFFBFF00000;
+    ans = 64'h43CFFFFFBFF00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"811511\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'hBC92546CCE634083;
+    ans = 64'hBC92546CCE634085;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"811817\n");
+    end
+    ReadData1E = 64'h9DD03FFFFFFFFF7F;
+    ReadData2E = 64'hBFE5AE33346526BE;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h1DC604EC0136BAAA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"812123\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"812429\n");
+    end
+    ReadData1E = 64'hA4BA947C9B590FEF;
+    ReadData2E = 64'hC7FBC71D8AAF5885;
+    ReadData3E = 64'hB7E9F7E971FFC3F6;
+    ans = 64'hB7E9F7E971FFC3F6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"812735\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC3FFFDFFF7FFFFFE;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'hC0BFFCFFF7FFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"813041\n");
+    end
+    ReadData1E = 64'h402100000FFFFFFE;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'hBF6007FFFFFFFFBE;
+    ans = 64'hBF600800000010BE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"813347\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h48000FFFEFFFFFFF;
+    ReadData3E = 64'hBF80EAC8590DC991;
+    ans = 64'h44C00FFFEFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"813653\n");
+    end
+    ReadData1E = 64'h4150000040001FFF;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h433FFFFFFFF00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"813959\n");
+    end
+    ReadData1E = 64'h37EFFFFFF8000006;
+    ReadData2E = 64'h401000000F7FFFFE;
+    ReadData3E = 64'h41D0000020001FFF;
+    ans = 64'h41D0000020001FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"814265\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'h4641C8183EC0208B;
+    ans = 64'h4641C8183EC0208B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"814571\n");
+    end
+    ReadData1E = 64'h40CDFFFFFF800000;
+    ReadData2E = 64'h3FB000000000000A;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'h408DFFFFFF800013;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"814877\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"815183\n");
+    end
+    ReadData1E = 64'h3FEC00000000001F;
+    ReadData2E = 64'h47EFFFFFEFFFFFEE;
+    ReadData3E = 64'h4046D38AE2B5B7C9;
+    ans = 64'h47EBFFFFF200000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"815489\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC1EFEFFFFFFFFE00;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFE00001FEFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"815795\n");
+    end
+    ReadData1E = 64'h3F9FFFFFFFFFF080;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'h4380000100000004;
+    ans = 64'h4380000100000004;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"816101\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h50AE6549B7B9413E;
+    ReadData3E = 64'hC0700000FFFFFF00;
+    ans = 64'h4D6E6549B7B9413C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"816407\n");
+    end
+    ReadData1E = 64'hC3F1FFFFFFFFFFF7;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'h43E1FFFFFFFFFFF6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"816713\n");
+    end
+    ReadData1E = 64'hC3CF000008000000;
+    ReadData2E = 64'h00000001F7FFFFFF;
+    ReadData3E = 64'hADC7AEB97D7AAA63;
+    ans = 64'hADC7AEB97D7AAA63;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"817019\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'h00107FFFEFFFFFFE;
+    ans = 64'hBC9FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"817325\n");
+    end
+    ReadData1E = 64'h400C00000FFFFFFE;
+    ReadData2E = 64'h3F803FFFFFC00000;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"817631\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h4340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"817937\n");
+    end
+    ReadData1E = 64'h43FEFFFFFFDFFFFE;
+    ReadData2E = 64'h3BE000003FFFFFF7;
+    ReadData3E = 64'h3F1F7FDFFFFFFFFE;
+    ans = 64'h3FEF00FC7ADFFFEC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"818243\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h40380000000000FE;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000060;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"818549\n");
+    end
+    ReadData1E = 64'h4310010040000000;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h373650909086FED3;
+    ans = 64'hC31001003FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"818855\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hCA64000000000FFF;
+    ReadData3E = 64'hC3E800000000FFFF;
+    ans = 64'hC724000000000FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"819161\n");
+    end
+    ReadData1E = 64'h447FFFEFFFFFFFFC;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'hC47FFFEFFFFFFFFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"819467\n");
+    end
+    ReadData1E = 64'hB800000400000000;
+    ReadData2E = 64'h400FFBFFFFDFFFFE;
+    ReadData3E = 64'hC9B000000000401E;
+    ans = 64'hC9B000000000401E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"819773\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'h3FF000000000DFFF;
+    ans = 64'h3FF000000000DFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"820079\n");
+    end
+    ReadData1E = 64'hBE40000020008000;
+    ReadData2E = 64'hC7ECCDDA5176EED4;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"820385\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"820691\n");
+    end
+    ReadData1E = 64'hD57E91FB06496C86;
+    ReadData2E = 64'h381B4E4682CE5ADB;
+    ReadData3E = 64'hDC6BFFFFFEFFFFFE;
+    ans = 64'hDC6BFFFFFEFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"820997\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBF110000000001FF;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCA0008800000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"821303\n");
+    end
+    ReadData1E = 64'hC0B0200000000003;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'hBFC1D73DADDDF9B6;
+    ans = 64'h40B01FDC5184A448;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"821609\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC009137C731CDB82;
+    ReadData3E = 64'h44500000001FFFDF;
+    ans = 64'h44500000001FFFDF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"821915\n");
+    end
+    ReadData1E = 64'h3F0FFBFFFFFFFFFA;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hC000003FF7FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"822221\n");
+    end
+    ReadData1E = 64'hBFDF3226C82519BB;
+    ReadData2E = 64'h093FFFFFFFFC0002;
+    ReadData3E = 64'hBBEF000000010000;
+    ans = 64'hBBEF000000010000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"822527\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h800FFFFFFFF00000;
+    ans = 64'hBCBFFFFFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"822833\n");
+    end
+    ReadData1E = 64'h40300FFDFFFFFFFF;
+    ReadData2E = 64'h411FFFFFFFFDFFFF;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"823139\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h400FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"823445\n");
+    end
+    ReadData1E = 64'h52B0200000FFFFFE;
+    ReadData2E = 64'hC7FDC39DD92F7A18;
+    ReadData3E = 64'hC940002001FFFFFF;
+    ans = 64'hDABDFF2516BE12E6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"823751\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FBF800001FFFFFF;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h3C7F800001FFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"824057\n");
+    end
+    ReadData1E = 64'h41C0010007FFFFFE;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'hA39000000403FFFF;
+    ans = 64'hC1D0010007FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"824363\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC7EBCC5F21936D2F;
+    ReadData3E = 64'hD65B21AA7893B120;
+    ans = 64'hD65B21AA7893B120;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"824669\n");
+    end
+    ReadData1E = 64'hC010400000008000;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h4031400000007FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"824975\n");
+    end
+    ReadData1E = 64'hBFD000003FFFFFFF;
+    ReadData2E = 64'h4060000020FFFFFE;
+    ReadData3E = 64'hC7FFE0000000003E;
+    ans = 64'hC7FFE0000000003E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"825281\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'hB9EFFFFFFFF60000;
+    ans = 64'hBCD000000000003E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"825587\n");
+    end
+    ReadData1E = 64'h41D00000FFFFFFF7;
+    ReadData2E = 64'h0E8000000000027F;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h434FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"825893\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"826199\n");
+    end
+    ReadData1E = 64'hC03FFFFFEFFFFE00;
+    ReadData2E = 64'hC1B69575AD8E4938;
+    ReadData3E = 64'hC03EF1A51B0A9C79;
+    ans = 64'h42069575A14BFFCF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"826505\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h401FEFFFFFFFBFFE;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h3CDFEFFFFFFFBFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"826811\n");
+    end
+    ReadData1E = 64'hB8008E2BDAE7849A;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'h4D700008000003FF;
+    ans = 64'h4D700008000003FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"827117\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h802F800003FFFFFE;
+    ReadData3E = 64'h3CA21EADA7E7EABE;
+    ans = 64'h3CA21EADA7E7EABE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"827423\n");
+    end
+    ReadData1E = 64'h40454B061F63C997;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'hC0655B061F63C998;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"827729\n");
+    end
+    ReadData1E = 64'hC3DFFDFF00000000;
+    ReadData2E = 64'hC34000FFFFFFFFEF;
+    ReadData3E = 64'h381FF7FFF8000000;
+    ans = 64'h472FFFFEDFEFFFDE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"828035\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFE2D34305DB32DD;
+    ans = 64'hFFE2D34305DB32DD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"828341\n");
+    end
+    ReadData1E = 64'hC3D4C997322DB688;
+    ReadData2E = 64'hC7EFFFFFE7FFFFFF;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'h4BD4C99722968522;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"828647\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h3FEFFFFFFFFFFFF0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"828953\n");
+    end
+    ReadData1E = 64'h43401FFFFFFFFFEF;
+    ReadData2E = 64'hBFC6B4955343E8C0;
+    ReadData3E = 64'h3FACA027F5F02257;
+    ans = 64'hC316E1FE7DEA7079;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"829259\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC0717FFFFFFFFFFE;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'hBD317FFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"829565\n");
+    end
+    ReadData1E = 64'h3F30200000007FFE;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'hBFEDFFF7FFFFFFFE;
+    ans = 64'hC28020000000877E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"829871\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h480FFF07FFFFFFFE;
+    ReadData3E = 64'hFFE0FFFFFFEFFFFF;
+    ans = 64'hFFE0FFFFFFEFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"830177\n");
+    end
+    ReadData1E = 64'h4340000010400000;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'hC690000010400001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"830483\n");
+    end
+    ReadData1E = 64'h801138665FBF5823;
+    ReadData2E = 64'h41C88AD4452DDA53;
+    ReadData3E = 64'h837330BE9EFFCD8A;
+    ans = 64'h837330BEAC34CFC6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"830789\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'hBE314AE1C1E96403;
+    ans = 64'hC0000000008A570E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"831095\n");
+    end
+    ReadData1E = 64'h000FFFB800000000;
+    ReadData2E = 64'hBFDFFFFFFE020000;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"831401\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'hC011FFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"831707\n");
+    end
+    ReadData1E = 64'hBE5F0A7A7523EF50;
+    ReadData2E = 64'hBFFFFFFFFFFC0010;
+    ReadData3E = 64'h3F800403FFFFFFFF;
+    ans = 64'h3F80040BC29E9D47;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"832013\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h3F7FFFC00000001E;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"832319\n");
+    end
+    ReadData1E = 64'h93B00004000FFFFE;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FAF4698DF3288FF;
+    ans = 64'h3FAF4698DF3288FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"832625\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC0CFFF7FFFFEFFFF;
+    ReadData3E = 64'h5175F45600193651;
+    ans = 64'h5175F45600193651;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"832931\n");
+    end
+    ReadData1E = 64'h41CDFFFFFFFFF000;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"833237\n");
+    end
+    ReadData1E = 64'h413FFFFFE0001000;
+    ReadData2E = 64'h43400000FFF7FFFF;
+    ReadData3E = 64'hD649F219711FB93B;
+    ans = 64'hD649F219711FB93B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"833543\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hB812005F57A6E0BC;
+    ans = 64'hFCA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"833849\n");
+    end
+    ReadData1E = 64'hC91FFEFFFFFFFFF0;
+    ReadData2E = 64'hDB00080000FFFFFF;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'h6430077FC0FFF7F7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"834155\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'hFCAFFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"834461\n");
+    end
+    ReadData1E = 64'h403F4AF7E517A201;
+    ReadData2E = 64'h41CFFC000000001F;
+    ReadData3E = 64'hCC6000000001E000;
+    ans = 64'hCC6000000001E000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"834767\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h801FFFFFDFEFFFFE;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"835073\n");
+    end
+    ReadData1E = 64'h37F000000000000F;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hDE9FF7FFFFFFFF7E;
+    ans = 64'hF7F000000000000E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"835379\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hC00007FFFFFFFFF8;
+    ReadData3E = 64'h3FDD260F6EE2590B;
+    ans = 64'h3FDD260F6EE25903;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"835685\n");
+    end
+    ReadData1E = 64'h3FFC0000003FFFFF;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"835991\n");
+    end
+    ReadData1E = 64'hC1EF000400000000;
+    ReadData2E = 64'h800000000FFFFFFE;
+    ReadData3E = 64'hBCA00800000000FF;
+    ans = 64'hBCA00800000000FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"836297\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'h4BEFFFFFFFFFFFF5;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"836603\n");
+    end
+    ReadData1E = 64'h41EFFFBF7FFFFFFE;
+    ReadData2E = 64'h4000400000000010;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h42003FDF3F10000F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"836909\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"837215\n");
+    end
+    ReadData1E = 64'h800000000FFFFBFE;
+    ReadData2E = 64'h3FFF168ED14CE3D1;
+    ReadData3E = 64'hC0301FFF7FFFFFFE;
+    ans = 64'hC0301FFF7FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"837521\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'h2200000000000420;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h434FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"837827\n");
+    end
+    ReadData1E = 64'hC1FF0000000001FF;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h000FFF0008000000;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"838133\n");
+    end
+    ReadData1E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData2E = 64'hBF5FFFFFFFDFFFFF;
+    ReadData3E = 64'h34B00FFFFFFFFFBE;
+    ans = 64'hBC1FFFFFFFDFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"838439\n");
+    end
+    ReadData1E = 64'hC1FFFFFFBFFFFFFF;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"838745\n");
+    end
+    ReadData1E = 64'hB7F0000040000020;
+    ReadData2E = 64'h37FFFFFF00000002;
+    ReadData3E = 64'h4057FFFFFFFF7FFF;
+    ans = 64'h4057FFFFFFFF7FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"839051\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'h37E000081FFFFFFF;
+    ans = 64'h37E000081FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"839357\n");
+    end
+    ReadData1E = 64'h41408003FFFFFFFF;
+    ReadData2E = 64'h3FC07FFFFFFFFEFE;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'h411104001FFFFEF5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"839663\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h3CA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"839969\n");
+    end
+    ReadData1E = 64'h43EBF2B862C4592E;
+    ReadData2E = 64'hC09F6B9863FDA598;
+    ReadData3E = 64'h40100DFFFFFFFFFE;
+    ans = 64'hC49B711B5078BE27;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"840275\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h47F00000007EFFFF;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'h47D00000007EFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"840581\n");
+    end
+    ReadData1E = 64'hBF9FFC0000001FFE;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'hA48FFBFFFFFFFF7E;
+    ans = 64'hA48FFBFFFFFFFF7E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"840887\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC021FFFFFFFFF7FE;
+    ReadData3E = 64'hCC7FFFFFDFFFFDFF;
+    ans = 64'hCC7FFFFFDFFFFDFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"841193\n");
+    end
+    ReadData1E = 64'h4017A9EC462C22C8;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h003BA9EC462C22C5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"841499\n");
+    end
+    ReadData1E = 64'hB7F0000000000086;
+    ReadData2E = 64'h4BFFFFFFE000FFFE;
+    ReadData3E = 64'hBF70000002000000;
+    ans = 64'hC3FFFFFFE001010A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"841805\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h80027DBC297E85BC;
+    ans = 64'h00018243D6817A44;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"842111\n");
+    end
+    ReadData1E = 64'h8540020000000FFF;
+    ReadData2E = 64'hBFFF3B0F41DCC6B0;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h3FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"842417\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h800C000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"842723\n");
+    end
+    ReadData1E = 64'h47F003FFFFFFFDFF;
+    ReadData2E = 64'hC3DFFFEFFFFFC000;
+    ReadData3E = 64'h43F400000000000F;
+    ans = 64'hCBE003F7FDFFDDF7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"843029\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h00000003FFFFFFFC;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h4010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"843335\n");
+    end
+    ReadData1E = 64'h402FF0000007FFFE;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'h3EEFFFFFFFFC4000;
+    ans = 64'h3EEFFFFFFFFC4000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"843641\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hB7EFFFFFBFFFFF7E;
+    ReadData3E = 64'hBFCE000000100000;
+    ans = 64'hBFCE000000100000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"843947\n");
+    end
+    ReadData1E = 64'hEBB4000FFFFFFFFF;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"844253\n");
+    end
+    ReadData1E = 64'h001CB8573191EF15;
+    ReadData2E = 64'hC19000800003FFFF;
+    ReadData3E = 64'h41EFFFFFE03FFFFF;
+    ans = 64'h41EFFFFFE03FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"844559\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFC00003FFFF7FFE;
+    ans = 64'hBFC00003FFFF7FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"844865\n");
+    end
+    ReadData1E = 64'h3334BE2D7996C148;
+    ReadData2E = 64'h3EC03F7FFFFFFFFE;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hBFD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"845171\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h3C80000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
@@ -64758,7189 +107785,11971 @@ initial
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
     	$fwrite(fp,"845477\n");
     end
-    x = 64'hC0B0488993492A6B;
-    y = 64'h5B1FFFFFDFC00000;
-    z = 64'h8010000000000001;
-    ans = 64'hDBE0488982E00FC5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h800F800000080000;
+    ReadData2E = 64'h7FD00000000037FF;
+    ReadData3E = 64'h483FFFFFDFF7FFFF;
+    ans = 64'h483FFFFFDFF7FFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"846091\n");
+    	$fwrite(fp,"845783\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hC000084000000000;
-    ans = 64'hC000084000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3FF000000FBFFFFE;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hC00DFFFFFE07FFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"846705\n");
+    	$fwrite(fp,"846089\n");
     end
-    x = 64'hC1EFFFFFC0007FFF;
-    y = 64'h3FFFFFFFFFFFFFEE;
-    z = 64'hC8BFFFFFC00003FE;
-    ans = 64'hC8BFFFFFC00003FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hA96FFFFFEFFBFFFF;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'hBFFBFFFFDFFFFFFF;
+    ans = 64'hBFFBFFFFDFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"847319\n");
+    	$fwrite(fp,"846395\n");
     end
-    x = 64'h375EFFFFFFFDFFFF;
-    y = 64'h3FD0000000000000;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h62BBFFFFEFFFFFFF;
+    ReadData3E = 64'h40300000403FFFFF;
+    ans = 64'h629BFFFFEFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"847933\n");
+    	$fwrite(fp,"846701\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hC000000400000006;
-    z = 64'hBC1FBFFF80000000;
-    ans = 64'hBFE0000400000006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h41CAB753F5C8C6D1;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"848547\n");
+    	$fwrite(fp,"847007\n");
     end
-    x = 64'hC7E0010000FFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hBF8FFFFFFFF83FFE;
-    ans = 64'hC7D0010000FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFF16C91BA884B3B;
+    ReadData2E = 64'h52E000000001E000;
+    ReadData3E = 64'h5A8000000FFEFFFF;
+    ans = 64'hFFF96C91BA884B3B;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"849161\n");
+    	$fwrite(fp,"847313\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hC0500800000001FE;
-    z = 64'h3FE0000000000001;
-    ans = 64'hC02F1000000003FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'h400EC0D680F9B3E5;
+    ans = 64'h400EC0D680F9B3E5;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"849775\n");
+    	$fwrite(fp,"847619\n");
     end
-    x = 64'hC800000004400000;
-    y = 64'hBE4FFFFEFFFF0000;
-    z = 64'h800FDBF9EA11BBF4;
-    ans = 64'h465FFFFF087EFFBC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FB7999C7249E9A2;
+    ReadData2E = 64'hC1C0040FFFFFFFFE;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'hC1879F9A7302EE63;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"850389\n");
+    	$fwrite(fp,"847925\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h3FE0000000000000;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFEC000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"851003\n");
-    end
-    x = 64'h420E5A3C24CF124B;
-    y = 64'hC1E07FFFFBFFFFFF;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'hC3FF4D0DFE5EFBD2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"851617\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h3FC3FFFFFFFC0000;
-    ans = 64'h3FD9FFFFFFFE0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"852231\n");
-    end
-    x = 64'hB80AF03ED31C2128;
-    y = 64'h43C0003FFE000000;
-    z = 64'h47FD72CA9372EDB0;
-    ans = 64'h47FD72CA9372EDB0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"852845\n");
-    end
-    x = 64'hB81FFFFFFDFFFFFA;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"853459\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hD414000000000000;
-    z = 64'hC3DBDCEC84BBB9FD;
-    ans = 64'hD3F4000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"854073\n");
-    end
-    x = 64'h37F10F90DAD1F099;
-    y = 64'h3FF0000000000001;
-    z = 64'hBE51FF9882DDA3CC;
-    ans = 64'hBE51FF9882DDA3CC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"854687\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hFFFA27F828AA83E8;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'hFFFA27F828AA83E8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"855301\n");
-    end
-    x = 64'hC01FFFFFFFC00008;
-    y = 64'hBFA7D979591E69F2;
-    z = 64'hB81FFFFFFFFC0004;
-    ans = 64'h3FD7D97958EEB705;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"855915\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"856529\n");
-    end
-    x = 64'h7FE0DFFFFFFFFFFF;
-    y = 64'hBFCFFFFFFFDFFBFF;
-    z = 64'h7FFFFFFFFFFFFFFE;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
     ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"857143\n");
+    	$fwrite(fp,"848231\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h4000000000000001;
-    z = 64'h8017C6373AB1DB0C;
-    ans = 64'h3FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFE0000000000000;
+    ReadData2E = 64'h43C87A46755279AC;
+    ReadData3E = 64'hC00EAE236666A2DC;
+    ans = 64'hC3B87A46755279AC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"857757\n");
+    	$fwrite(fp,"848537\n");
     end
-    x = 64'hBFE000800000003F;
-    y = 64'hC3D0040000003FFF;
-    z = 64'hBFBA1A85F9F711EA;
-    ans = 64'h43C0048020004040;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h400FFF7BFFFFFFFF;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h4007FFDEFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"858371\n");
+    	$fwrite(fp,"848843\n");
     end
-    x = 64'hC7F0001002000000;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC810001001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3F6FFFFFC0000010;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'h3F70000001FEFFFF;
+    ans = 64'h3F73FFFFF9FF0001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"858985\n");
+    	$fwrite(fp,"849149\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hBB12976036C01C4E;
-    z = 64'h7FDFFF800000000F;
-    ans = 64'h7FDFFF800000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3F8F73F460C4C31D;
+    ReadData3E = 64'h7FD542F883C0A5EF;
+    ans = 64'h7FD542F883C0A5EF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"859599\n");
+    	$fwrite(fp,"849455\n");
     end
-    x = 64'h3FFF4B7FA078868F;
-    y = 64'h4010000000000000;
-    z = 64'h80200000001FFFFF;
-    ans = 64'h401F4B7FA078868F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"860213\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hBFDCCB5937B9B37F;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'hBFBCCB5937B9B36F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"860827\n");
-    end
-    x = 64'h800000000000007E;
-    y = 64'hFFD26A0F710537A9;
-    z = 64'hC01B3B74DE550046;
-    ans = 64'hC01B3B74DE550022;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"861441\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'h3FF8000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"862055\n");
-    end
-    x = 64'hB9FC1DF69E92D913;
-    y = 64'h40800000040000FE;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"862669\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'h4340000000000000;
-    z = 64'hC80BB201F0787373;
-    ans = 64'hC80BB201F0787373;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"863283\n");
-    end
-    x = 64'hBE6CB25FEF8F51E0;
-    y = 64'hB0A0000000008002;
-    z = 64'hD5CFDFFFFDFFFFFF;
-    ans = 64'hD5CFDFFFFDFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"863897\n");
-    end
-    x = 64'h47EFFFFFFFFFBDFE;
-    y = 64'h4340000000000001;
-    z = 64'hC000000000000000;
-    ans = 64'h4B3FFFFFFFFFBE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"864511\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'h3800FDCBA1FA0B89;
-    z = 64'hC030003FFEFFFFFF;
-    ans = 64'hC030003FFEFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"865125\n");
-    end
-    x = 64'h35DD7F70FBF55C6F;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h7FEA275826182B56;
-    ans = 64'h7FEA275826182B56;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"865739\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hC3E0000000800007;
-    z = 64'h3CA0000000000000;
-    ans = 64'hC3C0000000800007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"866353\n");
-    end
-    x = 64'h4340FFFFFFFFF800;
-    y = 64'h38ADFFFFFFBFFFFE;
-    z = 64'hBFD589A27F2B5461;
-    ans = 64'hBFD589A27F2B5461;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"866967\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'h7FE0000000000001;
-    z = 64'hBFD0000000000000;
-    ans = 64'h7FC0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"867581\n");
-    end
-    x = 64'h38FFFFE07FFFFFFE;
-    y = 64'h434000007FFF7FFF;
-    z = 64'h7FE0000000000001;
+    ReadData1E = 64'hBE70002003FFFFFE;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'h7FE0000000000001;
     ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"868195\n");
+    	$fwrite(fp,"849761\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hB81000003FFFFF80;
-    ans = 64'h7FCFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC1C197CF2A7E3F8F;
+    ReadData2E = 64'hBFEFFFFFFFFF7FBE;
+    ReadData3E = 64'hC3CFFC00000FFFFF;
+    ans = 64'hC3CFFBFFFFFE6830;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"868809\n");
+    	$fwrite(fp,"850067\n");
     end
-    x = 64'hBD7FEFFFFFFF7FFF;
-    y = 64'hC1FFFFFFF000007E;
-    z = 64'h6FAFFFFFFFFFFBE0;
-    ans = 64'h6FAFFFFFFFFFFBE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFD0080000003FFE;
+    ans = 64'hBFC0100000007FFC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"869423\n");
+    	$fwrite(fp,"850373\n");
     end
-    x = 64'hC1E0000000003BFE;
-    y = 64'h7FF0000000000000;
-    z = 64'hBFF0000000000001;
+    ReadData1E = 64'h3FC00001FFFFDFFF;
+    ReadData2E = 64'hAF80000004100000;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'hAF500002040FE081;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"850679\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'hFFF0000000000000;
     ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"870037\n");
+    	$fwrite(fp,"850985\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h382100000001FFFF;
-    z = 64'h43D0000010800000;
-    ans = 64'h43D0000010800000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h417007FFDFFFFFFF;
+    ReadData2E = 64'h41F000FFFFFC0000;
+    ReadData3E = 64'hC0BFFFFFFFFFF880;
+    ans = 64'h437009005FF9FBFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"870651\n");
+    	$fwrite(fp,"851291\n");
     end
-    x = 64'h0EDFFFFFFFBFBFFE;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'hC70FFFFFFF7BFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBFF011FFFFFFFFFF;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF4048000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"871265\n");
+    	$fwrite(fp,"851597\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hC1FFF80FFFFFFFFF;
-    z = 64'h0010000000000001;
-    ans = 64'hC1DFF80FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBEE04000007FFFFF;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'h4396138DF7EB9A59;
+    ans = 64'h4396138DF7EB9A59;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"871879\n");
+    	$fwrite(fp,"851903\n");
     end
-    x = 64'h77500007FFFFFFFF;
-    y = 64'hB7EFFE0400000000;
-    z = 64'hC3CF7FFFFFFFFF00;
-    ans = 64'hEF4FFE13FF01FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBE1FFFBFFBFFFFFF;
+    ReadData3E = 64'hC7F00F8000000000;
+    ans = 64'hC7F00F8000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"872493\n");
+    	$fwrite(fp,"852209\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h8000000000000000;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB44FFFFFF000000F;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"873107\n");
+    	$fwrite(fp,"852515\n");
     end
-    x = 64'h41DFFFFFFFFFFBFE;
-    y = 64'hBFB00008007FFFFE;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFBFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0005396BB2A6A133;
+    ReadData2E = 64'h80214BC0C3457605;
+    ReadData3E = 64'hC02C6B4A0B5C3DD6;
+    ans = 64'hC02C6B4A0B5C3DD6;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"873721\n");
+    	$fwrite(fp,"852821\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hC3FFF0000003FFFF;
-    ans = 64'hC3FFF0000003FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'h7FD25208760C3106;
+    ans = 64'h7FD25208760C3106;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"874335\n");
+    	$fwrite(fp,"853127\n");
     end
-    x = 64'hBFE0000000000077;
-    y = 64'hC1E00000000003BE;
-    z = 64'hBFF000010000001F;
-    ans = 64'h41CFFFFFFF800862;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h34F00010003FFFFF;
+    ReadData2E = 64'h000335BE3408EDB3;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'h0010000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"874949\n");
+    	$fwrite(fp,"853433\n");
     end
-    x = 64'h3A800000027FFFFF;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"875563\n");
+    	$fwrite(fp,"853739\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hB2CFFFFE07FFFFFF;
-    z = 64'hBFBFFFFFFFE001FE;
-    ans = 64'hBFBFFFFFFFE001FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FF000FFFFFFFFFC;
+    ReadData2E = 64'hB807FFFFFFEFFFFE;
+    ReadData3E = 64'hC1F0000100000006;
+    ans = 64'hC1F0000100000006;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"876177\n");
+    	$fwrite(fp,"854045\n");
     end
-    x = 64'hC00FFE00FFFFFFFF;
-    y = 64'h8010000000000001;
-    z = 64'h9DAFFFFFC0000001;
-    ans = 64'h9DAFFFFFC0000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h42BA5BD75A09BAF5;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h429A5BD75A09BCF5;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"876791\n");
+    	$fwrite(fp,"854351\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hC30F8FBDC122265C;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hC2EF8FBDC122265C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC347ACE083F9E32E;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h3F8020000FFFFFFF;
+    ans = 64'hC347ACE083F9E32D;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"877405\n");
+    	$fwrite(fp,"854657\n");
     end
-    x = 64'h0E1FFFFFFFF0003F;
-    y = 64'h8D33FFFFFFFDFFFE;
-    z = 64'h43CF12C07801790B;
-    ans = 64'h43CF12C07801790B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hB87850D0E3E0A2DD;
+    ReadData3E = 64'hBFD0000000FFFFDE;
+    ans = 64'hBFD0000000FFFFDE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"878019\n");
+    	$fwrite(fp,"854963\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h8023FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB80FF8000003FFFE;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h401FFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"878633\n");
+    	$fwrite(fp,"855269\n");
     end
-    x = 64'hC16FFFFFFFFFFFFE;
-    y = 64'h43DFFF8003FFFFFF;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'hC55FFF8003FFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FE000000000000C;
+    ReadData2E = 64'hC3F54C10FC0D1720;
+    ReadData3E = 64'hBFFFFFEFFF7FFFFF;
+    ans = 64'hC3E54C10FC0D1730;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"879247\n");
+    	$fwrite(fp,"855575\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hBCA0000000000001;
-    z = 64'h37F00200FFFFFFFF;
-    ans = 64'hBC80000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'h43FFFFFFFFF80040;
+    ans = 64'h43FFFFFFFFF80040;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"879861\n");
+    	$fwrite(fp,"855881\n");
     end
-    x = 64'h001FB1D966CCDFCE;
-    y = 64'hBFC4E6F76095C1F4;
-    z = 64'h1B73746C9DC04BF1;
-    ans = 64'h1B73746C9DC04BF1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h41C2D222AA9A0638;
+    ReadData2E = 64'h43EFFFEFFFEFFFFF;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h45C2D219417F47D9;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"880475\n");
+    	$fwrite(fp,"856187\n");
     end
-    x = 64'h3D2FFFF820000000;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"881089\n");
+    	$fwrite(fp,"856493\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hC3FFFFFDFFFFF7FF;
-    z = 64'h3FE0000800FFFFFE;
-    ans = 64'hC3DFFFFDFFFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFE0800000001FFF;
+    ReadData2E = 64'h3FDFFFFFFE0001FF;
+    ReadData3E = 64'hBD9FFFE00000000F;
+    ans = 64'hBFD07FFFFEFA2104;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"881703\n");
+    	$fwrite(fp,"856799\n");
     end
-    x = 64'h43D3000000000000;
-    y = 64'hBFD0000000000000;
-    z = 64'hB7E7428087FE7255;
-    ans = 64'hC3B3000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hB810080010000000;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"882317\n");
+    	$fwrite(fp,"857105\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'h43CCB81C98B1BC94;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h402FFFFFFFFBFFDF;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h405BFFFFBFFFFFFF;
+    ans = 64'h4061FFFFDFFF7FFB;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"882931\n");
+    	$fwrite(fp,"857411\n");
     end
-    x = 64'h3FD4A71E4A6E4C00;
-    y = 64'h3FBFFFFFFFFFFDF6;
-    z = 64'h000FFFFFFF7FFE00;
-    ans = 64'h3FA4A71E4A6E4AAF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC1CFFF7FFFFEFFFF;
+    ReadData3E = 64'h79E000FFFFFFFFFD;
+    ans = 64'h79E000FFFFFFFFFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"883545\n");
+    	$fwrite(fp,"857717\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hBFBFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDF8E1FB8E7AC41;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC0081C7811C614F0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"884159\n");
+    	$fwrite(fp,"858023\n");
     end
-    x = 64'hBCA00004000003FF;
-    y = 64'h499FFFFFFFFFE800;
-    z = 64'h4010000000000000;
-    ans = 64'hC6500003FFFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hF4D0700000000000;
+    ReadData2E = 64'h4061AE8809F49782;
+    ReadData3E = 64'hC3EFFFFFF7FFFF7F;
+    ans = 64'hF5422A4DC23A47A7;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"884773\n");
+    	$fwrite(fp,"858329\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hBFE0000000000000;
-    z = 64'hC2BFFFFFFBBFFFFF;
-    ans = 64'hC2BFFFFFFBC0001F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'h7FD00000000003EF;
+    ans = 64'h7FD00000000003EF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"885387\n");
+    	$fwrite(fp,"858635\n");
     end
-    x = 64'hBCAFDFFFFFFFEFFF;
-    y = 64'hBFEFBFFFFEFFFFFF;
-    z = 64'h3819477BBAEEBE75;
-    ans = 64'h3CAFA03FFF00F01E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"886001\n");
-    end
-    x = 64'hBFEFFFFFFBFFFFBE;
-    y = 64'hBFE0000000000001;
-    z = 64'hBFD0000000000000;
-    ans = 64'h3FCFFFFFF7FFFF80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"886615\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'h3F71F00000000000;
-    z = 64'h001C00000000003F;
-    ans = 64'h3F51F00000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"887229\n");
-    end
-    x = 64'h3180000800000000;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h4010008000003FFF;
-    ans = 64'h4010008000003FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"887843\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hBFAFFFFFFFFF7BFF;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"888457\n");
-    end
-    x = 64'h00299FE07104D6A3;
-    y = 64'h3B7007FFFFFFEFFE;
-    z = 64'h43DFFFFFF0001000;
-    ans = 64'h43DFFFFFF0001000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"889071\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hBFF0000000000001;
-    z = 64'h8000000000000000;
-    ans = 64'hBFD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"889685\n");
-    end
-    x = 64'h3FCF4D325CFDD93C;
-    y = 64'h0016A743D6888DB5;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"890299\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hC0169EAB4642D2BE;
-    ans = 64'hC0189EAB4642D2BE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"890913\n");
-    end
-    x = 64'h449FFFFFDDFFFFFE;
-    y = 64'h3E4FFFFB7FFFFFFF;
-    z = 64'h3FB0EE0C1F0EC5E3;
-    ans = 64'h42FFFFFB5E0004C6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"891527\n");
-    end
-    x = 64'hC03FFFE000000001;
-    y = 64'hC000000000000000;
-    z = 64'hBCA0000000000001;
-    ans = 64'h404FFFE000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"892141\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hC00000004FFFFFFE;
-    z = 64'h40D0000000080100;
-    ans = 64'h40CFFFC0000EC200;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"892755\n");
-    end
-    x = 64'hBFA001FFFFFFC000;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h47E0FC03BF40CC75;
-    ans = 64'h47E0FC03BF40CC75;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"893369\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'h002000000FFFFFF7;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"893983\n");
-    end
-    x = 64'h4110000A00000000;
-    y = 64'h59BF221FD8F50EDA;
-    z = 64'h43F03FFFFFFFF7FF;
-    ans = 64'h5ADF22334E48F673;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"894597\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hC010000000000000;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"895211\n");
-    end
-    x = 64'hC12FFFFFFFE00000;
-    y = 64'hC3EFFEFFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h452FFEFFFFE000FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"895825\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hC5BEEB8D6F57D560;
-    ans = 64'hC5BEEB8D6F57D560;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"896439\n");
-    end
-    x = 64'h3CAFFFBFFFFFDFFF;
-    y = 64'hC1C5DE58051F8BE2;
-    z = 64'hC0E000000003FFBE;
-    ans = 64'hC0E0000000045737;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"897053\n");
-    end
-    x = 64'h3F2FFFFFFFFDF7FE;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'hBF5FFFFFFFFDF7FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"897667\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'h404001D305E5077D;
-    z = 64'h43E345C0BA2B4702;
-    ans = 64'h43E345C0BA2B4702;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"898281\n");
-    end
-    x = 64'h400FFEFFFFFEFFFF;
-    y = 64'hC340000000000001;
-    z = 64'hBFC8084BF0E72845;
-    ans = 64'hC35FFEFFFFFF0001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"898895\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'h451FC0FFFFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'h44FFC0FFFBFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"899509\n");
-    end
-    x = 64'h43AFFFFFBFFFFFFB;
-    y = 64'h801000001FFBFFFF;
-    z = 64'h41DFFFFFFFFFFFCE;
-    ans = 64'h41DFFFFFFFFFFFCE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"900123\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"900737\n");
-    end
-    x = 64'h6BFFFFBFFFFFFFFC;
-    y = 64'h283FFFFFFDFBFFFF;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h544FFFBFFDFC0403;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"901351\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hFFE0000000000000;
-    z = 64'h161FFFFFFFDFFFFF;
-    ans = 64'hFFC0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"901965\n");
-    end
-    x = 64'h37F2080000000000;
-    y = 64'h3FCEFFFFFFFFFFFF;
-    z = 64'h4340000000420000;
-    ans = 64'h4340000000420000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"902579\n");
-    end
-    x = 64'hB92000FFFF7FFFFF;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h792000FFFF7FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"903193\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hFFDBC6970DE3B50D;
-    z = 64'h40683D253D82068E;
-    ans = 64'hFFBBC6970DE3B50D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"903807\n");
-    end
-    x = 64'h41DFE00000003FFF;
-    y = 64'hFFF0000000000000;
-    z = 64'h3E2044A8CC924DF6;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"904421\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'h37FC1EB686A59815;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"905035\n");
-    end
-    x = 64'h3E400002FFFFFFFF;
-    y = 64'h381FFFFF40000000;
-    z = 64'hBE7403C848DDC703;
-    ans = 64'hBE7403C848DDC703;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"905649\n");
-    end
-    x = 64'h3FD0000000000000;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h434FFFFFFFFFFFFE;
+    ReadData1E = 64'hB7F0000FBFFFFFFF;
+    ReadData2E = 64'h3FC4294C9A3326B1;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
     ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"906263\n");
+    	$fwrite(fp,"858941\n");
     end
-    x = 64'h3FE23B78B59A3A59;
-    y = 64'hB8100E2F27603D95;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h4020FFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"906877\n");
+    	$fwrite(fp,"859247\n");
     end
-    x = 64'h3FD0000000000000;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h000000200000001E;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h37F000000FFFDFFE;
+    ReadData2E = 64'h0B900040000007FF;
+    ReadData3E = 64'hC61000407FFFFFFF;
+    ans = 64'hC61000407FFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"907491\n");
+    	$fwrite(fp,"859553\n");
     end
-    x = 64'h41CFFFC0000FFFFE;
-    y = 64'h43CFF7FFFFFFEFFF;
-    z = 64'hBF89D89F52C2F13F;
-    ans = 64'h45AFF7C0100FEBFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC7EFFFFFFFBFFFFA;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'hC7CFFFFFFFBFFFFA;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"908105\n");
+    	$fwrite(fp,"859859\n");
     end
-    x = 64'h47F9AA99D39DD7D8;
-    y = 64'h0000000000000001;
-    z = 64'h8000000000000000;
-    ans = 64'h04D9AA99D39DD7D8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h408FC007FFFFFFFE;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'hC0000000080FFFFF;
+    ans = 64'h40AFBC07FFFDFBFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"908719\n");
+    	$fwrite(fp,"860165\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'hE3D0000000017FFE;
-    z = 64'h43EFC00000001FFF;
-    ans = 64'hE3B0000000017FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC7E007FFFFFFBFFE;
+    ReadData3E = 64'h400000001FFFEFFF;
+    ans = 64'hC7C007FFFFFFBFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"909333\n");
+    	$fwrite(fp,"860471\n");
     end
-    x = 64'hFFDFFE0000003FFE;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h3FCFFFFFF6000000;
-    ans = 64'hBFFBFE0001403FFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FBFF80000000040;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'h4003FF0000000009;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"909947\n");
+    	$fwrite(fp,"860777\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'hC1DFDFFFFFFFFFBE;
-    z = 64'hC010000000000000;
-    ans = 64'hC1BFE00003FFFFC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC342000FFFFFFFFF;
+    ReadData2E = 64'hBFF00000000001FD;
+    ReadData3E = 64'h43FF0000000007FE;
+    ans = 64'h43FF0240020007FE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"910561\n");
+    	$fwrite(fp,"861083\n");
     end
-    x = 64'h3CA80FFFFFFFFFFE;
-    y = 64'hB7EAF87E635B0699;
-    z = 64'h3F5000000007FFF8;
-    ans = 64'h3F5000000007FFF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'hC3E4000000200000;
+    ans = 64'hC3E4000000200000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"911175\n");
+    	$fwrite(fp,"861389\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h0010000000000001;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h464010003FFFFFFE;
+    ReadData2E = 64'h42300000800FFFFF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"911789\n");
+    	$fwrite(fp,"861695\n");
     end
-    x = 64'hBFBFFFFFFFEFFFDF;
-    y = 64'hBE92E82AF51517D5;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000025D055EB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC008000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"912403\n");
+    	$fwrite(fp,"862001\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hBCA007FFFFFFFFFF;
-    ans = 64'hBCA007FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h404000020000001F;
+    ReadData2E = 64'hFA9FFFC000001FFF;
+    ReadData3E = 64'hC68FFFFFFFFFFB80;
+    ans = 64'hFAEFFFC3FFF8203D;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"913017\n");
+    	$fwrite(fp,"862307\n");
     end
-    x = 64'hC34FFFFFFE002000;
-    y = 64'h2E88C0F902659DDC;
-    z = 64'hB1AFFFFDFBFFFFFE;
-    ans = 64'hB1EAC0F8E099A70D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h9950008000000003;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hBCA0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"913631\n");
+    	$fwrite(fp,"862613\n");
     end
-    x = 64'hC7E003FFFFBFFFFF;
-    y = 64'h3CA0000000000000;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFFFFF0000100000;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'h40C5214A8EE75583;
+    ans = 64'h40C51D4AAEE75383;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"914245\n");
+    	$fwrite(fp,"862919\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'hB5DF393CDBFD0E56;
-    z = 64'h2FF001EFFFFFFFFF;
-    ans = 64'hB5BF393CDBFD0E58;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h5153FFFFFFFFBFFF;
+    ReadData3E = 64'hC35001FFFF000000;
+    ans = 64'h5133FFFFFFFFBFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"914859\n");
+    	$fwrite(fp,"863225\n");
     end
-    x = 64'h7FF000000FFFFDFF;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hC02FB1C8D71620A8;
-    ans = 64'h7FF800000FFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFDFFFFFFFFFFEBE;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"915473\n");
+    	$fwrite(fp,"863531\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h3D80000040020000;
-    z = 64'hC000000000000001;
-    ans = 64'hBFFFFFFFFFFFF802;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFF8B44D2CF18037;
+    ReadData2E = 64'h3D200000043FFFFF;
+    ReadData3E = 64'h43E7FBFFFFFFFFFF;
+    ans = 64'hFFF8B44D2CF18037;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"916087\n");
+    	$fwrite(fp,"863837\n");
     end
-    x = 64'hC01B8BE39B34B0D4;
-    y = 64'hBFE02000000007FE;
-    z = 64'h41D000000000803F;
-    ans = 64'h41D0000000DE981A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'h41E000800000001E;
+    ans = 64'h41E000800040001E;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"916701\n");
+    	$fwrite(fp,"864143\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h3FD0000000000000;
-    z = 64'h4010000000000001;
-    ans = 64'h4010400000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FB0800000000003;
+    ReadData2E = 64'hB9600400007FFFFE;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"917315\n");
+    	$fwrite(fp,"864449\n");
     end
-    x = 64'hBCA00FFFFFFFFFFE;
-    y = 64'h4FEFFFFFFFFFDDFF;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'hCCA00FFFFFFFEEEC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"917929\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h3FD0000000000001;
-    z = 64'h3FCF035416EA0254;
-    ans = 64'h3FD381AA0B75012B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"918543\n");
-    end
-    x = 64'hBB20000000000800;
-    y = 64'h3800000008400000;
-    z = 64'h4340000090000000;
-    ans = 64'h4340000090000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"919157\n");
-    end
-    x = 64'h47F000000001F800;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"919771\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h4000010003FFFFFF;
-    z = 64'h347FFFFFFFE00004;
-    ans = 64'h3FE0010004000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"920385\n");
-    end
-    x = 64'h41D56D000350CB1C;
-    y = 64'h3FE0000000000000;
-    z = 64'h405D74B8307164A8;
-    ans = 64'h41C56D003E3A3B7D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"920999\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hC00000FFFFFFFFC0;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hC004003FFFFFFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"921613\n");
-    end
-    x = 64'h3CACF1F103A120CF;
-    y = 64'h47BFFFBFFFFFC000;
-    z = 64'hC2E3FEFFFFFFFFFF;
-    ans = 64'h447CF1B715BF5FA9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"922227\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h4010FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"922841\n");
-    end
-    x = 64'hCE40000000000210;
-    y = 64'h3FEFF81FFFFFFFFF;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'hCE3FF8200000041E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"923455\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h3FF0000000000000;
-    z = 64'h0452200000000000;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"924069\n");
-    end
-    x = 64'h3F80000200000FFF;
-    y = 64'h3810000000FFE000;
-    z = 64'h43EB023AC93CBEFB;
-    ans = 64'h43EB023AC93CBEFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"924683\n");
-    end
-    x = 64'h400AE69468F30B18;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h4350000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"925297\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h47FFFDFFFFFFF7FF;
-    z = 64'hBFEFF0000000001F;
-    ans = 64'h47DFFDFFFFFFF801;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"925911\n");
-    end
-    x = 64'hC7FFFFFFFFF000FE;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h7FE129213A6A1E19;
-    ans = 64'h7FE129213A6A1E19;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"926525\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h41F1FFFFFF800000;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h41D1FFFFFF400001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"927139\n");
-    end
-    x = 64'h43FFFFFFFFFFFFFF;
-    y = 64'hBFFF7027F837860A;
-    z = 64'h38100100000FFFFF;
-    ans = 64'hC40F7027F8378609;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"927753\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h4007FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"928367\n");
-    end
-    x = 64'hB7000000201FFFFE;
-    y = 64'h403C000080000000;
-    z = 64'h0010000000000000;
-    ans = 64'hB74C0000B83800FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"928981\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h3FDFFFFFFFFDEFFF;
-    ans = 64'h3FF7FFFFFFFF7C00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"929595\n");
-    end
-    x = 64'h41EFFFFFFFFFE03F;
-    y = 64'hC3F0800000010000;
-    z = 64'h4000000000000006;
-    ans = 64'hC5F080000000EFA0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"930209\n");
-    end
-    x = 64'hBFD04D24C5BAD8C9;
-    y = 64'h4010000000000001;
-    z = 64'h4340000000000000;
-    ans = 64'h433FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"930823\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h43EFFBFFFFFFFFF7;
-    z = 64'h4FBFBFC000000000;
-    ans = 64'h4FBFBFC000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"931437\n");
-    end
-    x = 64'h2106EEC68B20AD3B;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h8013FFFE00000000;
-    ans = 64'h2136EEC68B20AD3A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"932051\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hB8CFFFDFFDFFFFFF;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"932665\n");
-    end
-    x = 64'h7FF00001FFFFFF7F;
-    y = 64'h43EFFF7FBFFFFFFF;
-    z = 64'hC09FFFFFDFFFFF80;
-    ans = 64'h7FF80001FFFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"933279\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h4340000000000001;
-    z = 64'h3FF0000000000000;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'h4000000000000001;
     ans = 64'h4320000000000004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"933893\n");
+    	$fwrite(fp,"864755\n");
     end
-    x = 64'h407E7C49B84A1813;
-    y = 64'h7FEC9DC7A22C5F2A;
-    z = 64'h0000000000000001;
+    ReadData1E = 64'h3DFFFFFFEFDFFFFF;
+    ReadData2E = 64'h43D0000FFFBFFFFF;
+    ReadData3E = 64'h802FEFFDFFFFFFFE;
+    ans = 64'h41E0000FF7AFF7EF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"865061\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3E6ABE5E424DBD3F;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h3E4ABE5E424DBD3F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"865367\n");
+    end
+    ReadData1E = 64'hBFB909D69E02A222;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'h380EFFFFFFFFFFEF;
+    ans = 64'hC30909D69E02A224;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"865673\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h38100000007EFFFF;
+    ReadData3E = 64'hC39FFFFFFE1FFFFF;
+    ans = 64'hC39FFFFFFE1FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"865979\n");
+    end
+    ReadData1E = 64'h002FFFFFFF000400;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'h3FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"866285\n");
+    end
+    ReadData1E = 64'h453FFFFFF0000003;
+    ReadData2E = 64'h47F00000047FFFFF;
+    ReadData3E = 64'hC0238DB0F8672290;
+    ans = 64'h4D3FFFFFF8FFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"866591\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'hC1E7E7CD6D9B2D7E;
+    ans = 64'h432FFFFE81832925;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"866897\n");
+    end
+    ReadData1E = 64'h3FCC803E813F7834;
+    ReadData2E = 64'hC3E010000001FFFE;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'hC3BC7CBEBFC447B0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"867203\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'h432FFFFFFFFFFFFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"867509\n");
+    end
+    ReadData1E = 64'h052FF00004000000;
+    ReadData2E = 64'h47E007FFFE000000;
+    ReadData3E = 64'hDBE2000000007FFE;
+    ans = 64'hDBE2000000007FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"867815\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBFE00FC000000000;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'hBFC00FC000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"868121\n");
+    end
+    ReadData1E = 64'hC3DC1BC00754990F;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'hD87E57C40FADB738;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"868427\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3E10010007FFFFFE;
+    ReadData3E = 64'h413000000007FFFF;
+    ans = 64'h4130000000080000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"868733\n");
+    end
+    ReadData1E = 64'h3EA1DF1B96B50BDF;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'h7E91DF1B96B50BE0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"869039\n");
+    end
+    ReadData1E = 64'h9B50000000000FEE;
+    ReadData2E = 64'hBFFFE00000080000;
+    ReadData3E = 64'hFFF02B3B3E780E07;
+    ans = 64'hFFF82B3B3E780E07;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"869345\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h401C08C927D263F5;
+    ans = 64'h7FCFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"869651\n");
+    end
+    ReadData1E = 64'h37EEFBFFFFFFFFFF;
+    ReadData2E = 64'hDFB0002001000000;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hD7AEFC3DF9EFBFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"869957\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'h7FCFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"870263\n");
+    end
+    ReadData1E = 64'h3ECFFFFC000000FF;
+    ReadData2E = 64'hC1FFFE3FFFFFFFFE;
+    ReadData3E = 64'hFFFFFEFFFFFFF7FF;
+    ans = 64'hFFFFFEFFFFFFF7FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"870569\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBF0FEF8000000000;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"870875\n");
+    end
+    ReadData1E = 64'h2550003FFFFFFFEF;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'hAAA103DECE05BF0F;
     ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"934507\n");
+    	$fwrite(fp,"871181\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hC66000008000001F;
-    ans = 64'hC66000008000001D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hFFFF0000000001FE;
+    ReadData3E = 64'h2D80000000001FF7;
+    ans = 64'hFFFF0000000001FE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"935121\n");
+    	$fwrite(fp,"871487\n");
     end
-    x = 64'h3E70FFFFFF000000;
-    y = 64'h400FFF8100000000;
-    z = 64'h426000100001FFFF;
-    ans = 64'h426000100001FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h41D7748AB1A3FE5C;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"935735\n");
+    	$fwrite(fp,"871793\n");
     end
-    x = 64'hBDDBFFFFFEFFFFFF;
-    y = 64'h7FE0000000000000;
-    z = 64'h4010000000000001;
+    ReadData1E = 64'h800D0D06EE913F9A;
+    ReadData2E = 64'h3DFFE0007FFFFFFE;
+    ReadData3E = 64'h3FCFDFFFFFFFDFFE;
+    ans = 64'h3FCFDFFFFFFFDFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"872099\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'hC000523B717EC726;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"872405\n");
+    end
+    ReadData1E = 64'hC1F4B64F0908F803;
+    ReadData2E = 64'h2EF00008000001FF;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h400FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"872711\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"873017\n");
+    end
+    ReadData1E = 64'h47EFFFFC00000FFF;
+    ReadData2E = 64'hC7F0000000A00000;
+    ReadData3E = 64'hBF8FFFFFFFF803FF;
+    ans = 64'hCFEFFFFC01400FD7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"873323\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h41D81517C3598347;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"873629\n");
+    end
+    ReadData1E = 64'h47F55D8D580F7615;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC3BF17E3E4C41B97;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"873935\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBCA1CA7B0D7924D0;
+    ReadData3E = 64'h002A7B153AF12BAD;
+    ans = 64'hBC81CA7B0D7924D0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"874241\n");
+    end
+    ReadData1E = 64'hC7163FA8199608CB;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hBCAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"874547\n");
+    end
+    ReadData1E = 64'hBFC00001FDFFFFFF;
+    ReadData2E = 64'hC4D0000020000007;
+    ReadData3E = 64'hE2EFFFFBFFFFFFFE;
+    ans = 64'hE2EFFFFBFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"874853\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'hC417FFFFFFFFFFBF;
+    ans = 64'hC417FFFFFFFFFFBF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"875159\n");
+    end
+    ReadData1E = 64'h801FFFFFFDFFFF7F;
+    ReadData2E = 64'h7FD0000000008FFE;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hC00FFFFFFF008FBD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"875465\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"875771\n");
+    end
+    ReadData1E = 64'h3CA5C07DE83266F8;
+    ReadData2E = 64'h800FFFFFFFFFEF00;
+    ReadData3E = 64'h5770000010080000;
+    ans = 64'h5770000010080000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"876077\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h4DD000001FFFFFFA;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"876383\n");
+    end
+    ReadData1E = 64'hCEF4C8D3D8B55D06;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'hA51F200000000000;
+    ans = 64'hA51F200000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"876689\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC0300000080003FF;
+    ReadData3E = 64'h43DD48A0CE4511A9;
+    ans = 64'h43DD48A0CE4511A9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"876995\n");
+    end
+    ReadData1E = 64'h524B89CF496B0D8A;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h926B89CF496B0D8A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"877301\n");
+    end
+    ReadData1E = 64'h47F00002000000FF;
+    ReadData2E = 64'hB85000000001FFF7;
+    ReadData3E = 64'h41E0800000000000;
+    ans = 64'h41E07FFFF7FFFF00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"877607\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'h4030EE949384D389;
+    ans = 64'h4030EE949384D389;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"877913\n");
+    end
+    ReadData1E = 64'hBF00000001001FFE;
+    ReadData2E = 64'h415001FFFFFFFBFF;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'hC05FC40002007802;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"878219\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hBCAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"878525\n");
+    end
+    ReadData1E = 64'hC01E32185C15D267;
+    ReadData2E = 64'h40184C07F358ED80;
+    ReadData3E = 64'hBE69FFFFFFFFFFFF;
+    ans = 64'hC046ED50BFE8B8A0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"878831\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hCD200000000003BF;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'hCD000000000003BF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"879137\n");
+    end
+    ReadData1E = 64'hC7F5F2DFDDF5DD2D;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h20C00000007BFFFE;
+    ans = 64'h20C00000007BFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"879443\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hB810000000000FFC;
+    ReadData3E = 64'h400FBFFFFFFF7FFF;
+    ans = 64'h400FBFFFFFFF7FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"879749\n");
+    end
+    ReadData1E = 64'h7FFFFFFFBFFFFF7F;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h7FFFFFFFBFFFFF7F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"880055\n");
+    end
+    ReadData1E = 64'hBFDFFFFFFEFFFFFF;
+    ReadData2E = 64'hC044AF12B6A74C7E;
+    ReadData3E = 64'h3C251824E2D48BA5;
+    ans = 64'h4034AF12B601D3E8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"880361\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'hB7E0000040000007;
+    ans = 64'hBC80000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"880667\n");
+    end
+    ReadData1E = 64'h3FB00000100003FE;
+    ReadData2E = 64'hC01FFFFF80001FFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hBFF7FFFFE80009DE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"880973\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'hBC80000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"881279\n");
+    end
+    ReadData1E = 64'h401D507E92C5E594;
+    ReadData2E = 64'h000F620D896F063D;
+    ReadData3E = 64'hBE2FFFFEFFFFBFFF;
+    ans = 64'hBE2FFFFEFFFFBFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"881585\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBFEFFFFFFFFFBDFF;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hC0207FFFFFFFFEF7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"881891\n");
+    end
+    ReadData1E = 64'hC3D0002000010000;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'h002FFFFFFFBFFFFE;
+    ans = 64'h409000200000FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"882197\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h41ED56A3C3AB3F70;
+    ReadData3E = 64'hC3F0003FFFFFFFF7;
+    ans = 64'hC3F0003FFFFC5523;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"882503\n");
+    end
+    ReadData1E = 64'h43EFFE000000007F;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'hC0AFFE000000007D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"882809\n");
+    end
+    ReadData1E = 64'h434FFFFF00000002;
+    ReadData2E = 64'hC1DBCB06C86758B7;
+    ReadData3E = 64'h406FE00000001000;
+    ans = 64'hC53BCB05EA0F2276;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"883115\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'h381F8003FFFFFFFF;
+    ans = 64'hBC8FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"883421\n");
+    end
+    ReadData1E = 64'h4303C48ADE74C3B5;
+    ReadData2E = 64'h00200027FFFFFFFE;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h3FDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"883727\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'hBFB0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"884033\n");
+    end
+    ReadData1E = 64'hDE90020000007FFF;
+    ReadData2E = 64'h3FD0000400000010;
+    ReadData3E = 64'hC3EE5C580A6A45A4;
+    ans = 64'hDE7002040080800F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"884339\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h37E454181AF8A93E;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"884645\n");
+    end
+    ReadData1E = 64'hFFE000200003FFFF;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'h0020CEB3FC1309E7;
+    ans = 64'h7FC0002000040000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"884951\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3FB007FFFFFFFFBF;
+    ReadData3E = 64'hD00FFFFFFFFE0002;
+    ans = 64'hD00FFFFFFFFE0002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"885257\n");
+    end
+    ReadData1E = 64'hB7E0001001FFFFFF;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"885563\n");
+    end
+    ReadData1E = 64'hBFF0000000000803;
+    ReadData2E = 64'hEADE000000400000;
+    ReadData3E = 64'h401FFBFFFFFFFFF0;
+    ans = 64'h6ADE000000400F06;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"885869\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'hC17FFFFFFFF7FFFD;
+    ans = 64'hC180000000FBFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"886175\n");
+    end
+    ReadData1E = 64'h4010005FFFFFFFFF;
+    ReadData2E = 64'h43E0000100400000;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'h440000610046017F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"886481\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'hBFC0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"886787\n");
+    end
+    ReadData1E = 64'hC21DFFFFDFFFFFFF;
+    ReadData2E = 64'h41EF7FFFFFFFFFFD;
+    ReadData3E = 64'h3FC2C86C00258B86;
+    ans = 64'hC41D87FFE07FFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"887093\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3FE0000081FFFFFF;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hBFFDFFFFEFC00002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"887399\n");
+    end
+    ReadData1E = 64'hBFB000000007C000;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'hBF5E0000003FFFFF;
+    ans = 64'h3F9E2000000B8002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"887705\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hB8000000000005FF;
+    ReadData3E = 64'h3FE00002001FFFFE;
+    ans = 64'h3FE00002001FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"888011\n");
+    end
+    ReadData1E = 64'h3E3000100007FFFE;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"888317\n");
+    end
+    ReadData1E = 64'hC3F0FFFFFF7FFFFF;
+    ReadData2E = 64'h41FFFEFFFFFFFFFB;
+    ReadData3E = 64'hBD9FFFFFFFFFFFDD;
+    ans = 64'hC600FF77FF8003FC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"888623\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hD6DFFFFDFFFFDFFE;
+    ans = 64'hD6DFFFFDFFFFDFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"888929\n");
+    end
+    ReadData1E = 64'h3CAFFFF7FFEFFFFF;
+    ReadData2E = 64'h3FFDB1E7398F283A;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'h3CC2D8EFE6834071;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"889235\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"889541\n");
+    end
+    ReadData1E = 64'hC02FFFFF80003FFF;
+    ReadData2E = 64'h05B041FFFFFFFFFF;
+    ReadData3E = 64'hBFDFFEFFFFFFFFBE;
+    ans = 64'hBFDFFEFFFFFFFFBE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"889847\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3FF6779EE2033B07;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h4002CEF3DC406760;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"890153\n");
+    end
+    ReadData1E = 64'h3FF044898012431F;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'h3EC774E18486AEBC;
+    ans = 64'hBFF044869176128E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"890459\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBFFFFFF000000000;
+    ReadData3E = 64'h4010000402000000;
+    ans = 64'h400C000A04000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"890765\n");
+    end
+    ReadData1E = 64'hC2A0000008002000;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"891071\n");
+    end
+    ReadData1E = 64'hBFA2EDC3DB985385;
+    ReadData2E = 64'h4043EFFFFFFFFFFE;
+    ReadData3E = 64'hC1FFFFFFFFFFFFFF;
+    ans = 64'hC2000000000BCB23;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"891377\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h408000000000007E;
+    ans = 64'h407FF800000000FC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"891683\n");
+    end
+    ReadData1E = 64'h0012D90EB735AC29;
+    ReadData2E = 64'h41E00000000006FF;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h0202D90EB6F5B467;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"891989\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"892295\n");
+    end
+    ReadData1E = 64'h6C26B0BFD2FBCAAE;
+    ReadData2E = 64'hC300000005000000;
+    ReadData3E = 64'h2380021000000000;
+    ans = 64'hEF36B0BFDA1306A0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"892601\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hF4100400007FFFFE;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hF3F00400007FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"892907\n");
+    end
+    ReadData1E = 64'hC02FFFFFFFFFFE1F;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'h7FDFFFFFFFFF8004;
+    ans = 64'h7FDFFFFFFFFF8004;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"893213\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hBFFFFFFFFBFFEFFE;
+    ReadData3E = 64'h43F00040000000FF;
+    ans = 64'h43F00040000000FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"893519\n");
+    end
+    ReadData1E = 64'h41EBFFFFFFFFFF80;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC3400000E0000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"893825\n");
+    end
+    ReadData1E = 64'h3C9B86D50A168045;
+    ReadData2E = 64'hFFDF7FFFFE000000;
+    ReadData3E = 64'hFFFFFFFFFF7FFFDF;
+    ans = 64'hFFFFFFFFFF7FFFDF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"894131\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'h3800003FFFFFEFFF;
+    ans = 64'hBFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"894437\n");
+    end
+    ReadData1E = 64'h4023805779AA7BA6;
+    ReadData2E = 64'h41F0000000000000;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'h4223805779AA7BA6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"894743\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"895049\n");
+    end
+    ReadData1E = 64'hB751FFFBFFFFFFFF;
+    ReadData2E = 64'hC3C9ED9349BBCC6D;
+    ReadData3E = 64'h38100000FFFFFFC0;
+    ans = 64'h3B2D2B3F378E7392;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"895355\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h7E1FFFFFFFFFDFF0;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h7DFFFFFFFFFFDFF0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"895661\n");
+    end
+    ReadData1E = 64'hBAE0000000003FFF;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFB35446159C93A3;
+    ans = 64'hBFB35446159C93A3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"895967\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h3A9DFFFFFFFFFEFF;
+    ReadData3E = 64'hB8000000FFFFFDFE;
+    ans = 64'h3A7DFFFFFFFFDEFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"896273\n");
+    end
+    ReadData1E = 64'hBFCF52E5F0E06610;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h4021F52E5F0E0660;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"896579\n");
+    end
+    ReadData1E = 64'h802E487204168AE2;
+    ReadData2E = 64'h3FD0002080000000;
+    ReadData3E = 64'h7FDFFFFC01FFFFFF;
+    ans = 64'h7FDFFFFC01FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"896885\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'hC1F3FFFFFFFEFFFF;
+    ans = 64'hC1F40000000EFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"897191\n");
+    end
+    ReadData1E = 64'hC01F000001000000;
+    ReadData2E = 64'hBFE000200001FFFF;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h400F003E0103E1FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"897497\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC340000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"897803\n");
+    end
+    ReadData1E = 64'hB7F0220000000000;
+    ReadData2E = 64'h4804298279080EA6;
+    ReadData3E = 64'h43E0000FFFFFFFBE;
+    ans = 64'h43E0000FFFFFFFBE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"898109\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC90000040000FFFE;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hC8E000040000FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"898415\n");
+    end
+    ReadData1E = 64'h3FF1896CDCA1FBD1;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'h802400000FFFFFFF;
+    ans = 64'hC021896CDCA1FBD0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"898721\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC01FFFBC00000000;
+    ReadData3E = 64'hB7E52B803F675515;
+    ans = 64'hBFFFFFBC00000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"899027\n");
+    end
+    ReadData1E = 64'h41D3FD5D0A16B1AB;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hC203FD5D0A36B1AA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"899333\n");
+    end
+    ReadData1E = 64'hB7F0200000000004;
+    ReadData2E = 64'hBFBFFFFFFFFF00FF;
+    ReadData3E = 64'hDFB3322F1716D84C;
+    ans = 64'hDFB3322F1716D84C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"899639\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'hC7E0040000000000;
+    ans = 64'hC7E0040000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"899945\n");
+    end
+    ReadData1E = 64'h43F020000003FFFF;
+    ReadData2E = 64'h0DF007FFFFFFC000;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"900251\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'hC31FFFFFFFFFFFE2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"900557\n");
+    end
+    ReadData1E = 64'hC80BFFFFFFFF8000;
+    ReadData2E = 64'hC36D1CF2F5E2A67E;
+    ReadData3E = 64'hC1FFFFFFFF007FFE;
+    ans = 64'h4B8979549725DD3A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"900863\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hFFFB6A3A2432DE41;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'hFFFB6A3A2432DE41;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"901169\n");
+    end
+    ReadData1E = 64'hC3E000000000407F;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'h3CAFFF9000000000;
+    ans = 64'h474000000000407E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"901475\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h2768D5A43EE64697;
+    ReadData3E = 64'h1AA00000FFFFBFFF;
+    ans = 64'h2748D5A43EE64697;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"901781\n");
+    end
+    ReadData1E = 64'h380FFFFFFFFFFFFF;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'h4000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"902087\n");
+    end
+    ReadData1E = 64'hC13F3F19214DF452;
+    ReadData2E = 64'h3FF0001FFFF00000;
+    ReadData3E = 64'h402FFFFFFFFFC7FF;
+    ans = 64'hC13F3F479F60F7D5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"902393\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'h3C5020007FFFFFFF;
+    ans = 64'hFFC0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"902699\n");
+    end
+    ReadData1E = 64'h3FEFFFFFF9FFFFFF;
+    ReadData2E = 64'h3F10000000008004;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"903005\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hFFC0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"903311\n");
+    end
+    ReadData1E = 64'h3FCFFFFFFC000010;
+    ReadData2E = 64'hBCA00000003FFBFE;
+    ReadData3E = 64'h5C6D7C81CE014EF9;
+    ans = 64'h5C6D7C81CE014EF9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"903617\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hC1FD2AEBDB57C7AA;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'hC1DD2AEBDB57C7AA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"903923\n");
+    end
+    ReadData1E = 64'hC0121AB24E47D412;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'h403FC00000010000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"904229\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h1FB0002FFFFFFFFF;
+    ReadData3E = 64'h380FFFEFFFE00000;
+    ans = 64'h380FFFEFFFE00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"904535\n");
+    end
+    ReadData1E = 64'h800F795795E454AD;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'h4006F2AF2BC8A959;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"904841\n");
+    end
+    ReadData1E = 64'h47EFFFFFFFFEFDFF;
+    ReadData2E = 64'hC080000780000000;
+    ReadData3E = 64'hBFE0000FFFFFDFFE;
+    ans = 64'hC88000077FFF7EFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"905147\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFD6C1C477639F3D;
+    ans = 64'hFFE360E23BB1CF9E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"905453\n");
+    end
+    ReadData1E = 64'hB80FFC0000004000;
+    ReadData2E = 64'h3FDC7ACB3D8E0D56;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"905759\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"906065\n");
+    end
+    ReadData1E = 64'h405FFF01FFFFFFFE;
+    ReadData2E = 64'h471E00FFFFFFFFFF;
+    ReadData3E = 64'h41D000000FFF7FFF;
+    ans = 64'h478E0011D80FFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"906371\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'h8EB00000017FFFFF;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'h8E900000017FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"906677\n");
+    end
+    ReadData1E = 64'hFFD40000000001FF;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'hBFDFFFFFFC008000;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"906983\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hFFFFFFFFE0000200;
+    ReadData3E = 64'h38120EB5CFFF927A;
+    ans = 64'hFFFFFFFFE0000200;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"907289\n");
+    end
+    ReadData1E = 64'hD960000000DFFFFF;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"907595\n");
+    end
+    ReadData1E = 64'h40DFFFFFFC040000;
+    ReadData2E = 64'h7FE000000020FFFF;
+    ReadData3E = 64'hFFF00000007FFEFE;
+    ans = 64'hFFF80000007FFEFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"907901\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h43EBFFFFFF7FFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"908207\n");
+    end
+    ReadData1E = 64'h381000003FFFFFFF;
+    ReadData2E = 64'hBF1886CB0D330AA3;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h4340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"908513\n");
+    end
+    ReadData1E = 64'h3FD0000000000000;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"908819\n");
+    end
+    ReadData1E = 64'h407ED04D6C9499F6;
+    ReadData2E = 64'h380FFFFEFFFBFFFE;
+    ReadData3E = 64'h3810000007FFFFE0;
+    ans = 64'h389EE04C76165486;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"909125\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hB02083FFFFFFFFFE;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'hB00083FFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"909431\n");
+    end
+    ReadData1E = 64'hB450000003DFFFFF;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'hC02FFFFFE0100000;
+    ans = 64'hC02FFFFFE0100000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"909737\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC3EFFFFF00003FFF;
+    ReadData3E = 64'hB7FF000000000002;
+    ans = 64'hC3CFFFFF00004001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"910043\n");
+    end
+    ReadData1E = 64'hB3DCBBCBF4FC7B3C;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"910349\n");
+    end
+    ReadData1E = 64'hC01FE7FFFFFFFFFF;
+    ReadData2E = 64'h43DFD4A9159E1E89;
+    ReadData3E = 64'h43C000000F7FFFFF;
+    ans = 64'hC40EBCC995D5E7F1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"910655\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'h59FFFE00000003FE;
+    ans = 64'h59FFFE00000003FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"910961\n");
+    end
+    ReadData1E = 64'hC7FE000000001FFF;
+    ReadData2E = 64'hC3CFFFFFFFFC0100;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'h4BDDFFFFFFFC60EF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"911267\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h3FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"911573\n");
+    end
+    ReadData1E = 64'h43D7DDC6B07E1242;
+    ReadData2E = 64'h7FD000000013FFFF;
+    ReadData3E = 64'hC34FFEFFFFFFFFE0;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"911879\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h21E1000000001FFF;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"912185\n");
+    end
+    ReadData1E = 64'h3BE00000008007FF;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'h45013FFFFFFFFFFF;
+    ans = 64'h45013FFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"912491\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h56DC000000000080;
+    ReadData3E = 64'hFFE0000000020010;
+    ans = 64'hFFE0000000020010;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"912797\n");
+    end
+    ReadData1E = 64'h5D9EF3F25478434E;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"913103\n");
+    end
+    ReadData1E = 64'hC01F00000000003E;
+    ReadData2E = 64'h72A001FFFFFFEFFF;
+    ReadData3E = 64'hBCE000007FFBFFFF;
+    ans = 64'hF2CF03DFFFFFE13C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"913409\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'h3CAFC07FFFFFFFFE;
+    ans = 64'h3CAFC07FFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"913715\n");
+    end
+    ReadData1E = 64'h429E54A46244D94F;
+    ReadData2E = 64'h41FEFFFFFFFFDFFE;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h44AD61FF3F32942E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"914021\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"914327\n");
+    end
+    ReadData1E = 64'hC3E00007FE000000;
+    ReadData2E = 64'h949F7FFFFDFFFFFF;
+    ReadData3E = 64'hC1E000003FFFF7FE;
+    ans = 64'hC1E000003FFFF7FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"914633\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBCA42A241576C81A;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"914939\n");
+    end
+    ReadData1E = 64'h41FFFF8000000010;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FF048A52C15DD23;
+    ans = 64'h3FF048A52C15DD23;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"915245\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBFD9E0724E2AFED0;
+    ReadData3E = 64'hC3DEACACA3A5320B;
+    ans = 64'hC3DEACACA3A5320B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"915551\n");
+    end
+    ReadData1E = 64'hC0FFFE00001FFFFF;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBDAFFE10001FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"915857\n");
+    end
+    ReadData1E = 64'hB80FFFF7FFFEFFFF;
+    ReadData2E = 64'h3F40000007FFFEFF;
+    ReadData3E = 64'h41EFFFFFEFBFFFFE;
+    ans = 64'h41EFFFFFEFBFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"916163\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h43440000000003FF;
+    ans = 64'h43440000000003FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"916469\n");
+    end
+    ReadData1E = 64'h3FC199DB34D4E268;
+    ReadData2E = 64'h402FF800000003FE;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'h3FC9574BE07AF628;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"916775\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"917081\n");
+    end
+    ReadData1E = 64'hFFD0003FBFFFFFFE;
+    ReadData2E = 64'hC00FFFFCFFFFFFFF;
+    ReadData3E = 64'h380FFFE000080000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"917387\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3F6FFFFFFFC40000;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"917693\n");
+    end
+    ReadData1E = 64'h4D60624F59DB184C;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'hC1CFFFFFFFFFFDDF;
+    ans = 64'h4A20624F59DB184B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"917999\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h4019CB37CAB5578C;
+    ReadData3E = 64'h002FFFFDFFFEFFFF;
+    ans = 64'h3FF9CB37CAB5578E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"918305\n");
+    end
+    ReadData1E = 64'hC3D5D738638A1944;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'hC3B5D738638A1944;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"918611\n");
+    end
+    ReadData1E = 64'hBFC00000FFFFFE00;
+    ReadData2E = 64'h30DFFE0000000007;
+    ReadData3E = 64'h3FDFFFF00000FFFE;
+    ans = 64'h3FDFFFF00000FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"918917\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'hB7E4C284CB2F81D3;
+    ans = 64'h3FB0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"919223\n");
+    end
+    ReadData1E = 64'hB7FEF5B5A6DCC55E;
+    ReadData2E = 64'hBFCFFFFFFF80003F;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h3FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"919529\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'h3FAFFFFFFFFFFFF4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"919835\n");
+    end
+    ReadData1E = 64'h4006E5FE7D1A8DC4;
+    ReadData2E = 64'h7FD80000001FFFFF;
+    ReadData3E = 64'h3F3000001FEFFFFF;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"920141\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h381FFFE000001000;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"920447\n");
+    end
+    ReadData1E = 64'h47EFFF7FFFEFFFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'h40AFFFFFFFFFFF08;
+    ans = 64'h47DFFF7FFFEFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"920753\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC0A1FFFFFFFFC000;
+    ReadData3E = 64'hCF783ACF6657D485;
+    ans = 64'hCF783ACF6657D485;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"921059\n");
+    end
+    ReadData1E = 64'h557BCB0C4F71816F;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h556BCB0C4F71816D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"921365\n");
+    end
+    ReadData1E = 64'h5920000107FFFFFF;
+    ReadData2E = 64'hBBD00000010003FF;
+    ReadData3E = 64'h2147FEFFFFFFFFFE;
+    ans = 64'hD50000010900040F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"921671\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'hC0355E7698BA0005;
+    ans = 64'hC0353E7698BA0005;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"921977\n");
+    end
+    ReadData1E = 64'h802E001FFFFFFFFF;
+    ReadData2E = 64'hB79FFFFDFFDFFFFE;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'hBFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"922283\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h3FC0000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"922589\n");
+    end
+    ReadData1E = 64'h43DFFFFFFFA00000;
+    ReadData2E = 64'hE0FFFE0000000000;
+    ReadData3E = 64'hC3EFF00010000000;
+    ans = 64'hE4EFFDFFFFA00600;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"922895\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC1D000002000007F;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC1B0000028000080;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"923201\n");
+    end
+    ReadData1E = 64'hC027F3B5DBAB58EF;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hC04FFF000001FFFF;
+    ans = 64'hC052FDF6BB766B1D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"923507\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h001FFFBDFFFFFFFE;
+    ReadData3E = 64'hBFDFFFFC01FFFFFF;
+    ans = 64'hBFDFFFFC01FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"923813\n");
+    end
+    ReadData1E = 64'h3FCDA0B73B3E429D;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'h3FCDA0B73B3E429B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"924119\n");
+    end
+    ReadData1E = 64'h43EFFFFEFFFFFFEF;
+    ReadData2E = 64'hB1A7F7D6729904E6;
+    ReadData3E = 64'hAD80008000002000;
+    ans = 64'hB5A7F7D5B2DA5144;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"924425\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h43F000800007FFFF;
+    ans = 64'h43F000800007FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"924731\n");
+    end
+    ReadData1E = 64'h7CD00004000000FF;
+    ReadData2E = 64'h3CA7FFFFBFFFFFFF;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h79880005BFFFF17D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"925037\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h3FD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"925343\n");
+    end
+    ReadData1E = 64'h3D5FEFFFFFDFFFFF;
+    ReadData2E = 64'h56B05A2CE13DEC1D;
+    ReadData3E = 64'hC1FFFFFFFF400000;
+    ans = 64'h542051FFCABCF2FA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"925649\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBFCFFFFDBFFFFFFE;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h400F800008FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"925955\n");
+    end
+    ReadData1E = 64'hBFC0000000000018;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'hC3F000000005FFFF;
+    ans = 64'hC3F000000005FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"926261\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hFFD26C3811E7D282;
+    ReadData3E = 64'h43E6E1E67A741F0C;
+    ans = 64'hFFB26C3811E7D283;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"926567\n");
+    end
+    ReadData1E = 64'hBFC70E2F42B43FA9;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"926873\n");
+    end
+    ReadData1E = 64'h3850000000000000;
+    ReadData2E = 64'h8010000000800080;
+    ReadData3E = 64'h3FB0020000000FFF;
+    ans = 64'h3FB0020000000FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"927179\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC3C0003F00000000;
+    ans = 64'hC3C0003F00000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"927485\n");
+    end
+    ReadData1E = 64'h400643BE798DFA0B;
+    ReadData2E = 64'hBFDB38C21CCBA9FC;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hBFF2F0A652A03F0C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"927791\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'h3FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"928097\n");
+    end
+    ReadData1E = 64'hC1FFC00000000400;
+    ReadData2E = 64'hBFDFFFFEFFFDFFFE;
+    ReadData3E = 64'hC1D000200000007F;
+    ans = 64'h41E7BFEF01FE07BF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"928403\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hB04ED49F5FEFA1FE;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hC000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"928709\n");
+    end
+    ReadData1E = 64'h3810000040040000;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'hC7EFFFFFFFDEFFFE;
+    ans = 64'hC7EFFFFFFFDEFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"929015\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC1D0000000080400;
+    ReadData3E = 64'h3FBFFFFC07FFFFFF;
+    ans = 64'hC1AFFFFFFFD0080A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"929321\n");
+    end
+    ReadData1E = 64'hC7E008000FFFFFFE;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"929627\n");
+    end
+    ReadData1E = 64'h8155FDEE412185B1;
+    ReadData2E = 64'h3F9FFFFFF8000FFE;
+    ReadData3E = 64'hC01000004FFFFFFE;
+    ans = 64'hC01000004FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"929933\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFFFFFFFFF0003FF;
+    ans = 64'hBFEFFFFFFE0007FD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"930239\n");
+    end
+    ReadData1E = 64'hB81F0000000007FF;
+    ReadData2E = 64'h4021FFFFFFFFFFDF;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h3CA0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"930545\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"930851\n");
+    end
+    ReadData1E = 64'h0020000040200000;
+    ReadData2E = 64'hB808F7D662C77EE8;
+    ReadData3E = 64'h7FDC9A96BB0DE738;
+    ans = 64'h7FDC9A96BB0DE738;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"931157\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h41D0000001FFFF80;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h41B0000002FFFF81;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"931463\n");
+    end
+    ReadData1E = 64'h244FFE0000000007;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'h4010000000FFFFFE;
+    ans = 64'h4010000000FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"931769\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h7FD000000000401F;
+    ReadData3E = 64'h43C6B4670C817DE7;
+    ans = 64'h7FB0000000004020;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"932075\n");
+    end
+    ReadData1E = 64'hC490000000090000;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'hC4AFFFFF80120002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"932381\n");
+    end
+    ReadData1E = 64'hBCA000000000077F;
+    ReadData2E = 64'h3FD000000000003F;
+    ReadData3E = 64'h37F4A35F530E6918;
+    ans = 64'hBC800000000007BE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"932687\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFF30581BE620614;
+    ans = 64'h3FE9F4FC833BF3DA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"932993\n");
+    end
+    ReadData1E = 64'h3FB0000400003FFE;
+    ReadData2E = 64'h41E000000007FFFC;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h41A0000400083FFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"933299\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"933605\n");
+    end
+    ReadData1E = 64'h3FC54E5D41712B9E;
+    ReadData2E = 64'h47E000010007FFFF;
+    ReadData3E = 64'h33C0002007FFFFFF;
+    ans = 64'h47B54E5E9661A6E2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"933911\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBFE00001FFF7FFFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hBFF200003FFF0000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"934217\n");
+    end
+    ReadData1E = 64'hBF1FFC0100000000;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'hB7E41A93A1F3F585;
+    ans = 64'hC26FFC0100000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"934523\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC7F0007FFFFFFEFF;
+    ReadData3E = 64'hB77FFFFFFFF8003F;
+    ans = 64'hC7D0007FFFFFFF00;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"934829\n");
+    end
+    ReadData1E = 64'hBF5FEFFBFFFFFFFE;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'hC34007FBFF000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"935135\n");
+    end
+    ReadData1E = 64'hC14400000003FFFE;
+    ReadData2E = 64'h402FFFFFE007FFFE;
+    ReadData3E = 64'h40070F2EB2AE69A8;
+    ans = 64'hC183FFFFD4F9D14A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"935441\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'hBF30000001FFF7FF;
+    ans = 64'h4320000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"935747\n");
+    end
+    ReadData1E = 64'h7FE3BD3ADDB19B8A;
+    ReadData2E = 64'h41E856C1AFCD15DF;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"936053\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h4353FFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"936359\n");
+    end
+    ReadData1E = 64'h8000000004004000;
+    ReadData2E = 64'hC7FFEFFFFFDFFFFE;
+    ReadData3E = 64'hBFDFFFE000100000;
+    ans = 64'hBFDFFFE000100000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"936665\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hF4E2706CF518E262;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'hF4C2706CF518E263;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"936971\n");
+    end
+    ReadData1E = 64'h82D59DA4597BE47B;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'hC0000000008007FF;
+    ans = 64'hC0000000008007FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"937277\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBF40000000003F7E;
+    ReadData3E = 64'h036000000000017F;
+    ans = 64'hBF20000000003F7F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"937583\n");
+    end
+    ReadData1E = 64'hBDDBFFFFFEFFFFFF;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'h4010000000000001;
     ans = 64'hFDCBFFFFFEFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"936349\n");
+    	$fwrite(fp,"937889\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h4344EFFCAA357859;
-    z = 64'h3CAFFF000000007E;
-    ans = 64'h4324EFFCAA35785A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB7FFFFFFFFFF7FF8;
+    ReadData2E = 64'h41E9D8AF3D98FD59;
+    ReadData3E = 64'h3FCCA1065CC75F03;
+    ans = 64'h3FCCA1065CC75F03;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"936963\n");
+    	$fwrite(fp,"938195\n");
     end
-    x = 64'hBFA1E04D77711DA5;
-    y = 64'h7FE0000000000001;
-    z = 64'h37E79B4E706CAB4B;
-    ans = 64'hFF91E04D77711DA6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'h400003FBFFFFFFFF;
+    ans = 64'h7FC0000000000002;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"937577\n");
+    	$fwrite(fp,"938501\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'hB81000080000001E;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h23B930F468025F01;
+    ReadData2E = 64'hBFF0AC6DEFA519FB;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"938191\n");
+    	$fwrite(fp,"938807\n");
     end
-    x = 64'h41FFFE8000000000;
-    y = 64'h3FCFFF7FFFDFFFFF;
-    z = 64'hF61FFC8000000000;
-    ans = 64'hF61FFC8000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'h7FC0000000000002;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"938805\n");
+    	$fwrite(fp,"939113\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h7FF0000000000000;
-    z = 64'h3FE0000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h401A984CEE2CCFDF;
+    ReadData2E = 64'h2E8FFFDFFFFFFFBF;
+    ReadData3E = 64'hBFBFFFBFFFFFEFFF;
+    ans = 64'hBFBFFFBFFFFFEFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
@@ -71949,7189 +119758,11971 @@ initial
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
     	$fwrite(fp,"939419\n");
     end
-    x = 64'h3FC287A64DA52860;
-    y = 64'h1C903FFFFFC00000;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC3492C4DB0C5D4CF;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'hC3292C4DB0C5D4D1;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"940033\n");
+    	$fwrite(fp,"939725\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h7FF0000000000001;
-    z = 64'hBCA82E7990B52CC4;
+    ReadData1E = 64'h41EAAC2889278322;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFD20001FFFFFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"940031\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC032A56D96C76E30;
+    ReadData3E = 64'hB81000000002FFFF;
+    ans = 64'hC012A56D96C76E31;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"940337\n");
+    end
+    ReadData1E = 64'h3FE0003FFFFFFFBF;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'h7FE0003FFFFFFFBE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"940643\n");
+    end
+    ReadData1E = 64'h936FFFC000000006;
+    ReadData2E = 64'h43FF81FFFFFFFFFF;
+    ReadData3E = 64'hC3CFFFFFFFFC001E;
+    ans = 64'hC3CFFFFFFFFC001E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"940949\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h42DC090B99823732;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"941255\n");
+    end
+    ReadData1E = 64'h3EE0000FFFFFFDFF;
+    ReadData2E = 64'h3800004000002000;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"941561\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'h4010000000000001;
     ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"940647\n");
+    	$fwrite(fp,"941867\n");
     end
-    x = 64'hC010000003FBFFFF;
-    y = 64'hC7E38964973306D4;
-    z = 64'hB80004FFFFFFFFFE;
-    ans = 64'h480389649C107D9F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB7F0000000FFFFF8;
+    ReadData2E = 64'h47FFFEFFFFFFFFFD;
+    ReadData3E = 64'h43D003FDFFFFFFFE;
+    ans = 64'h43D003FDFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"941261\n");
+    	$fwrite(fp,"942173\n");
     end
-    x = 64'h3DE46B9905A7DCC3;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h400FFFFFFFFFFFFF;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h41D24652A1E9AC61;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'h41B24652A1E9AC62;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"942479\n");
+    end
+    ReadData1E = 64'h3C9003FFF8000000;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h3F2FFFFF000FFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"942785\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3FB3971FA94CB21A;
+    ReadData3E = 64'h407FFFFFFFFDFFFF;
+    ans = 64'h408000272E3E5299;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"943091\n");
+    end
+    ReadData1E = 64'h37E800000000001F;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
     ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"941875\n");
+    	$fwrite(fp,"943397\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h7FF0EF17815B5D60;
-    z = 64'h15AC93DCB8E5466F;
-    ans = 64'h7FF8EF17815B5D60;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC1E00001E0000000;
+    ReadData2E = 64'h47EFFEFFFFC00000;
+    ReadData3E = 64'hBFC0000001BFFFFF;
+    ans = 64'hC9DFFF03BFA1FFF9;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"942489\n");
+    	$fwrite(fp,"943703\n");
     end
-    x = 64'h80102FFFFFFFFFFF;
-    y = 64'h8000000000000000;
-    z = 64'hB7EFFFFF5FFFFFFF;
-    ans = 64'hB7EFFFFF5FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'h37F5CAD1D5067C14;
+    ans = 64'h37F5CAD1D5067C14;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"943103\n");
+    	$fwrite(fp,"944009\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h800363A5C355B338;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB7E000000FFFFFFE;
+    ReadData2E = 64'hB3AFFEFFFDFFFFFF;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"943717\n");
+    	$fwrite(fp,"944315\n");
     end
-    x = 64'h388238397A22857F;
-    y = 64'hBCCDFFFBFFFFFFFE;
-    z = 64'hBFBBFFFFF8000000;
-    ans = 64'hBFBBFFFFF8000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hC00FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"944331\n");
+    	$fwrite(fp,"944621\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h801FFF7FFFFFF7FF;
+    ReadData2E = 64'hB52FFFFE00000002;
+    ReadData3E = 64'h38700007FFFFFFEF;
+    ans = 64'h38700007FFFFFFEF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"944945\n");
+    	$fwrite(fp,"944927\n");
     end
-    x = 64'h41AFFFFFFFBF7FFF;
-    y = 64'hC0091C99F8B11DCA;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h381FFFFFF7FFFF00;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'h37FFFFFFF7FFFF02;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"945559\n");
+    	$fwrite(fp,"945233\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h8010000000000000;
-    z = 64'h3CA814604180F249;
-    ans = 64'h3CA814604180F249;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC0000004003FFFFE;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'h41DFFFEFFFDFFFFF;
+    ans = 64'h41DFFFEFFFDFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"946173\n");
+    	$fwrite(fp,"945539\n");
     end
-    x = 64'h3FCFFF80001FFFFF;
-    y = 64'h3FECEAFB782ECD40;
-    z = 64'hC3D9BA4276C0833E;
-    ans = 64'hC3D9BA4276C0833E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC3CFFFFFF0200000;
+    ReadData3E = 64'h3FF000200000FFFE;
+    ans = 64'hC3AFFFFFF0200002;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"946787\n");
+    	$fwrite(fp,"945845\n");
     end
-    x = 64'h64A007F7FFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC00C000000100000;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"947401\n");
+    	$fwrite(fp,"946151\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h380FFFFFFFFFFFEF;
-    z = 64'hC01FFFFFBFFFFFBF;
-    ans = 64'hC01FFFFFBFFFFFBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h5DA0000203FFFFFE;
+    ReadData2E = 64'h3F5FBFFFFFC00000;
+    ReadData3E = 64'h3BEFFFFC00000FFF;
+    ans = 64'h5D0FC003FFAFFFF4;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"948015\n");
+    	$fwrite(fp,"946457\n");
     end
-    x = 64'hA5D382EB96AD50AD;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hC5300000FFFFF800;
-    ans = 64'hC5300000FFFFF800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'h43E0000FFF000000;
+    ans = 64'h43E0000FFF000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"948629\n");
+    	$fwrite(fp,"946763\n");
     end
-    x = 64'h3FD0000000000001;
-    y = 64'h3FCFFFFFFFFBFFFF;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h3FAFFFFFFFFC0001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"949243\n");
-    end
-    x = 64'h400FFFFFFE000200;
-    y = 64'hC7E08000000003FF;
-    z = 64'hC030000000003FF0;
-    ans = 64'hC8007FFFFEF80507;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"949857\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CA7FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"950471\n");
-    end
-    x = 64'h3FFFFFFFFFF80FFF;
-    y = 64'hC3F0000000000081;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"951085\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h002F0003FFFFFFFF;
-    ans = 64'hBC90000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"951699\n");
-    end
-    x = 64'hBFBFFFFFFFFFFFFF;
-    y = 64'h00100000000001F7;
-    z = 64'h37FFFEFFFFFFFEFF;
-    ans = 64'h37FFFEFFFFFFFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"952313\n");
-    end
-    x = 64'h3E771CF6C17F0752;
-    y = 64'hBFD0000000000001;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FEFFFFFF471849F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"952927\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hBFB0008000000FFF;
-    z = 64'h40DB1A37D21A1798;
-    ans = 64'h40DB1A36D2121798;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"953541\n");
-    end
-    x = 64'hBFDFFBFF80000000;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hBFB000000007FFF0;
-    ans = 64'h3FC7FBFF7FFC0007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"954155\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hC033697E014548B4;
-    z = 64'h8010000000000000;
-    ans = 64'hC013697E014548B5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"954769\n");
-    end
-    x = 64'hBFFA87A874A05E30;
-    y = 64'hC8211E73E27BE4D9;
-    z = 64'h53F00003FFFFFFF7;
-    ans = 64'h53F00003FFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"955383\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hBFE0000000000001;
-    z = 64'h3CA0000000000000;
-    ans = 64'hBFBFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"955997\n");
-    end
-    x = 64'hBFDFFC3FFFFFFFFF;
-    y = 64'h40103FFFFFFDFFFF;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"956611\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hBF145491BF6D4A83;
-    ans = 64'hBFD00145491BF6D5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"957225\n");
-    end
-    x = 64'h408C000001FFFFFF;
-    y = 64'h0001FFFFFFFFFF00;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"957839\n");
-    end
-    x = 64'h96CFFFFFFBFFFFFF;
-    y = 64'hBFF0000000000000;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"958453\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hC7F100FE84589A72;
-    z = 64'h3A9FFBFDFFFFFFFF;
-    ans = 64'hC7D100FE84589A73;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"959067\n");
-    end
-    x = 64'hC3CE1EC5802CC41D;
-    y = 64'hBFF0000000000001;
-    z = 64'hBFFFFFF8000FFFFE;
-    ans = 64'h43CE1EC5802CC41F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"959681\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h41D0000000000400;
-    z = 64'h8000000000000001;
-    ans = 64'h41B0000000000401;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"960295\n");
-    end
-    x = 64'h3FC0000200020000;
-    y = 64'hCC503FFFFFFFEFFF;
-    z = 64'h402BD7CA595315B7;
-    ans = 64'hCC2040020801F7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"960909\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hC000000000000000;
-    z = 64'h0010000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"961523\n");
-    end
-    x = 64'h4133D265E1ABC512;
-    y = 64'h3806B3BED3DAFA47;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"962137\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hC000000000000001;
-    z = 64'h444FFFFFFFFE0FFF;
-    ans = 64'h444FFFFFFFFE0FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"962751\n");
-    end
-    x = 64'hC7FFC00000000200;
-    y = 64'h374FFFFFFFFF81FF;
-    z = 64'h3CF99D8CF88F4CC9;
-    ans = 64'hBF5FBFFFFFFF1E85;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"963365\n");
-    end
-    x = 64'hB7F000000004003E;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"963979\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h40301FFFFFFFFDFF;
-    z = 64'hB81BFFFFFFFFF000;
-    ans = 64'h40101FFFFFFFFE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"964593\n");
-    end
-    x = 64'hC02AB5A6C8558DF5;
-    y = 64'hC010000000000000;
-    z = 64'hC04EF71DE29A8DE5;
-    ans = 64'hC02105DC6913FFC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"965207\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h8008AB84C5B2AF24;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"965821\n");
-    end
-    x = 64'h3FB13CA24F24198A;
-    y = 64'h031FC7FFFFFFFFFF;
-    z = 64'hC7CFFDFFFFFF0000;
-    ans = 64'hC7CFFDFFFFFF0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"966435\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"967049\n");
-    end
-    x = 64'h40139F95932450BC;
-    y = 64'h3FCF7FFF7FFFFFFF;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC006577488D34B68;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"967663\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hC340000000000000;
-    z = 64'h002FFEFFFFFEFFFF;
-    ans = 64'hC320000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"968277\n");
-    end
-    x = 64'h41EFFFFFF7FFFFFC;
-    y = 64'h40D000080001FFFF;
-    z = 64'h403EFFFDFFFFFFFF;
-    ans = 64'h42D00007FC0205BD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"968891\n");
-    end
-    x = 64'hC80FFFFF6FFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h4B6FFFFF6FFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"969505\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h43D000FFF7FFFFFE;
-    z = 64'hBF8EFDFFFFFFFFFF;
-    ans = 64'h43B000FFF7FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"970119\n");
-    end
-    x = 64'h00200000002001FF;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hC7E000000000100F;
-    ans = 64'hC7E000000000100F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"970733\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'h126000000002007F;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"971347\n");
-    end
-    x = 64'h3FDFFFFFFEF00000;
-    y = 64'hC01010000000000F;
-    z = 64'h3FEFFFFFFFFDFBFF;
-    ans = 64'hBFF01FFFFEEFF21E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"971961\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hFFE0000000000001;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"972575\n");
-    end
-    x = 64'h3EFFFC000000001E;
-    y = 64'hBFEFFFFFFFFFEDFF;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000FFE000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"973189\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h401FBFFFF7FFFFFE;
-    ans = 64'hFFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"973803\n");
-    end
-    x = 64'h473FFFFF88000000;
-    y = 64'hB040FFFFFBFFFFFF;
-    z = 64'hC160000002FFFFFE;
-    ans = 64'hC160000002FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"974417\n");
-    end
-    x = 64'hC1D037A403FC67CA;
-    y = 64'hFFF0000000000001;
-    z = 64'h3CA0000000000000;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"975031\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hC7FFFFFFFFFF0040;
-    z = 64'hC0105563F3CA3EC6;
-    ans = 64'hC7DFFFFFFFFF0042;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"975645\n");
-    end
-    x = 64'h37FFFDFFFDFFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h53E00000047FFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"976259\n");
-    end
-    x = 64'h3FD0000000000001;
-    y = 64'hBEAFF800001FFFFE;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"976873\n");
-    end
-    x = 64'hC1F003DFFFFFFFFF;
-    y = 64'h401E15640A85ECF6;
-    z = 64'hC7F00080000001FF;
-    ans = 64'hC7F00080000001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"977487\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h0000000000000000;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"978101\n");
-    end
-    x = 64'hBFE0000008007FFE;
-    y = 64'hBF3FF8000000FFFF;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFEFFE007FFF0022;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"978715\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h3E40000000400FFE;
-    ans = 64'h3E40000000400FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"979329\n");
-    end
-    x = 64'hBEE07FFFFFE00000;
-    y = 64'hBCA971847D137B50;
-    z = 64'hBFDFE00001FFFFFF;
-    ans = 64'hBFDFE00001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"979943\n");
-    end
-    x = 64'hC3C8F08B471AE667;
-    y = 64'h0010000000000000;
-    z = 64'h0010000000000001;
-    ans = 64'h83E8F08B471AE667;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"980557\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hBC1FFE0000100000;
-    z = 64'hBFF00001FBFFFFFF;
-    ans = 64'hBFF00001FBFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"981171\n");
-    end
-    x = 64'h3FFFFFFFFFFFDEFF;
-    y = 64'h0010000000000001;
-    z = 64'hB560400007FFFFFF;
-    ans = 64'hB560400007FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"981785\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h39300000F8000000;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"982399\n");
-    end
-    x = 64'hD090FFFFFFFFFFC0;
-    y = 64'h3FBFFFFFFFFFEFF6;
-    z = 64'hC02FFFFFEF000000;
-    ans = 64'hD060FFFFFFFFF73B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"983013\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"983627\n");
-    end
-    x = 64'hBFF0100001FFFFFF;
-    y = 64'h317FFFFFFFFFFC1E;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"984241\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h3CA0000000000001;
-    z = 64'h3E5FFFFFFFFE0002;
-    ans = 64'h3E600000007F0001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"984855\n");
-    end
-    x = 64'hBFF2502429256768;
-    y = 64'hC7F2ED05D0BFF7AA;
-    z = 64'h2B964D394AA258C9;
-    ans = 64'h47F5A9726DE4697B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"985469\n");
-    end
-    x = 64'hBFC0000400000000;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hBC800003FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"986083\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h7FFFFF7FEFFFFFFF;
-    z = 64'hC00000002000FFFF;
-    ans = 64'h7FFFFF7FEFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"986697\n");
-    end
-    x = 64'h3FCF80003FFFFFFF;
-    y = 64'h3FD0000000000000;
-    z = 64'h4BA081FFFFFFFFFE;
-    ans = 64'h4BA081FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"987311\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hC010202000000000;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h4017EFEFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"987925\n");
-    end
-    x = 64'h002FC07FFFFFFFFE;
-    y = 64'hBC40001000020000;
-    z = 64'h3930000000FF7FFF;
-    ans = 64'h3930000000FF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"988539\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFF;
+    ReadData1E = 64'h37F54C04C2DD9BA8;
+    ReadData2E = 64'hBFB0017FFFFFFFFF;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
     ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"989153\n");
+    	$fwrite(fp,"947069\n");
     end
-    x = 64'hBFF57175CE514C3A;
-    y = 64'hAEDA36C72E77963A;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'h3FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"989767\n");
+    	$fwrite(fp,"947375\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h3FE0000000000000;
-    z = 64'hB81D8C6AFBEFCF8A;
-    ans = 64'h3FCFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hACDFFF7FFFFFFBFE;
+    ReadData2E = 64'h3FD0000FFFBFFFFE;
+    ReadData3E = 64'hC01FFFFFFF7FFFDF;
+    ans = 64'hC01FFFFFFF7FFFDF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"990381\n");
+    	$fwrite(fp,"947681\n");
     end
-    x = 64'h3FDFC00000000006;
-    y = 64'h3D908358E704FD5A;
-    z = 64'h3CAFFFFFFF0007FF;
-    ans = 64'h3D8062D23536EF63;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC1D00000DFFFFFFE;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'hC1B00000DFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"990995\n");
+    	$fwrite(fp,"947987\n");
     end
-    x = 64'hBCB003FF7FFFFFFF;
-    y = 64'h3FE0000000000001;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h47E000040000000F;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'hBF50000007FFFBFF;
+    ans = 64'hBF50000007FFFBFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"991609\n");
+    	$fwrite(fp,"948293\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h0007DFFFFFFFFFFE;
-    z = 64'h41DFFFFFDFFFE000;
-    ans = 64'h41DFFFFFDFFFE000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC80FFFF7FF7FFFFE;
+    ReadData3E = 64'h802FFF8000800000;
+    ans = 64'hC7EFFFF7FF800000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"992223\n");
+    	$fwrite(fp,"948599\n");
     end
-    x = 64'hBCA7FFFFFFFFFFC0;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hB3B6000000000000;
-    ans = 64'hBCA7FFFFFFFFFFBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB9C01FFFFFFFF800;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h3FE0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"992837\n");
+    	$fwrite(fp,"948905\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h38100000FDFFFFFE;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFC0001007FFFFFE;
+    ReadData2E = 64'hBFD10000000001FF;
+    ReadData3E = 64'h99700000013FFFFF;
+    ans = 64'h3FA10011088001FD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"993451\n");
+    	$fwrite(fp,"949211\n");
     end
-    x = 64'h37F0000008000000;
-    y = 64'h3FDFFFFFFFF00008;
-    z = 64'h73300F7FFFFFFFFF;
-    ans = 64'h73300F7FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'hC3D0000000013FFF;
+    ans = 64'hC3D0000000013FFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"994065\n");
+    	$fwrite(fp,"949517\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h3FF0000000000001;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01DFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC38C638EECC31ABD;
+    ReadData2E = 64'hC1E0003FFE000000;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h457C640077725BEC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"994679\n");
+    	$fwrite(fp,"949823\n");
     end
-    x = 64'h3C0FFFFFFFFEF7FF;
-    y = 64'hB4CFFFFFFFFFFFFF;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hBFF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"995293\n");
+    	$fwrite(fp,"950129\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h480FFFFFFFFFFF3E;
-    ans = 64'h480FFFFFFFFFFF3E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h4024C8265CB4F296;
+    ReadData2E = 64'hC033F2685AF47617;
+    ReadData3E = 64'h3FF17E93439BFDF1;
+    ans = 64'hC069C58B36E690F8;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"995907\n");
+    	$fwrite(fp,"950435\n");
     end
-    x = 64'h6A10000000080010;
-    y = 64'hC021000000000001;
-    z = 64'h43F0003FFFFFDFFF;
-    ans = 64'hEA41000000088012;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBCA001000001FFFF;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'hBC80010000020000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"996521\n");
+    	$fwrite(fp,"950741\n");
     end
-    x = 64'h3FF0000007FFF000;
-    y = 64'h4000000000000000;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h401FFFFFE0000080;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'hC13FFFEFFF800000;
+    ans = 64'hC13FFFEFFF800000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"997135\n");
+    	$fwrite(fp,"951047\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hC00867B6EE5CD554;
-    z = 64'h480FFFFFFFEFFBFF;
-    ans = 64'h480FFFFFFFEFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h407FFFFFFFFFFFFF;
+    ReadData3E = 64'hB7FFFFFFFFFBFF7F;
+    ans = 64'h4060000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"997749\n");
+    	$fwrite(fp,"951353\n");
     end
-    x = 64'h36BF0007FFFFFFFF;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h400FC00000000000;
-    ans = 64'h400FC00000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FC0000000000BFE;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"998363\n");
+    	$fwrite(fp,"951659\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h3CA0000000000240;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h20E0000000780000;
+    ReadData2E = 64'h3880801FFFFFFFFF;
+    ReadData3E = 64'h4020000008080000;
+    ans = 64'h4020000008080000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"998977\n");
+    	$fwrite(fp,"951965\n");
     end
-    x = 64'hC02FFFFFFFFF7DFF;
-    y = 64'hD29FFFE1FFFFFFFF;
-    z = 64'hD095BF0E8082970E;
-    ans = 64'h52DFFFE1FFFE220E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'h381000000001001E;
+    ans = 64'hBC90000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"999591\n");
+    	$fwrite(fp,"952271\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h4010000000000000;
-    z = 64'hC010000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1000205\n");
-    end
-    x = 64'h41C03FFF7FFFFFFE;
-    y = 64'hC1DA356842BBA7BA;
-    z = 64'hBCA0000000000001;
-    ans = 64'hC3AA9E3D121B5440;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1000819\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hC0C3FFDFFFFFFFFF;
-    ans = 64'hC0C3FDDFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1001433\n");
-    end
-    x = 64'hC1CFFE0007FFFFFF;
-    y = 64'h80000001FFFFFFFB;
-    z = 64'h3EE00001FFEFFFFF;
-    ans = 64'h3EE00001FFEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1002047\n");
-    end
-    x = 64'h41CFFFFFF000007F;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1002661\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h7FFFFFFFFF8007FF;
-    z = 64'h3F25B91F0BABFF28;
-    ans = 64'h7FFFFFFFFF8007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1003275\n");
-    end
-    x = 64'h40EE0A93E8691D04;
-    y = 64'h4340000000000001;
-    z = 64'hC7FFEFFFFBFFFFFF;
-    ans = 64'hC7FFEFFFFBFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1003889\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h7FF007FF7FFFFFFF;
-    z = 64'h3FF0000000000001;
-    ans = 64'h7FF807FF7FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1004503\n");
-    end
-    x = 64'hC5700000003FC000;
-    y = 64'h583FFFDFFFFFFF7E;
-    z = 64'h3FCFDFFFFFFFFFFF;
-    ans = 64'hDDBFFFE0007F7EFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1005117\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hC000000000000001;
-    ans = 64'h433FFFFFFFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1005731\n");
-    end
-    x = 64'h47F4511545A3B643;
-    y = 64'hC39FFC0000010000;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'hCBA44E8B22FBA455;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1006345\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h7FE0000000000001;
-    z = 64'h002FFFFFFFC04000;
-    ans = 64'h7FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1006959\n");
-    end
-    x = 64'h41CD1B44159CA902;
-    y = 64'h7FFFFFFBFFFFFFFF;
-    z = 64'hBFE6D13A7491C894;
-    ans = 64'h7FFFFFFBFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1007573\n");
-    end
-    x = 64'h4602638FB47E42DE;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1008187\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h402000000000040F;
-    z = 64'h41CFF7FFFDFFFFFF;
-    ans = 64'h41CFF7FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1008801\n");
-    end
-    x = 64'h3C4EFFFFFFFFEFFE;
-    y = 64'h7FF0000000000000;
-    z = 64'hBEEE03FFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1009415\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h43EFFC0000001FFE;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h43DFFC0000001FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1010029\n");
-    end
-    x = 64'hC7EFFF000007FFFF;
-    y = 64'h802FFFFFF0000400;
-    z = 64'hC3CE000001FFFFFF;
-    ans = 64'hC3CE000001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1010643\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1011257\n");
-    end
-    x = 64'h3FEFFFFFFFFFE07F;
-    y = 64'hC3C0000002000FFE;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hC3C000000200003D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1011871\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h8000000000000000;
-    z = 64'h43CFC00400000000;
-    ans = 64'h43CFC00400000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1012485\n");
-    end
-    x = 64'hAB85C1F0653D248E;
-    y = 64'hC3FFFFFFFFBE0000;
-    z = 64'h3FD41CD3A8479F2D;
-    ans = 64'h3FD41CD3A8479F2D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1013099\n");
-    end
-    x = 64'h41DFFFF000008000;
-    y = 64'h8000000000000001;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1013713\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hC66E09CF3AF6E013;
-    z = 64'h511B551EA6EE8C23;
-    ans = 64'h511B551EA6EE8C23;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1014327\n");
-    end
-    x = 64'h403A4AD510299EB1;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h1BCDE79C5FF69901;
-    ans = 64'h1BCDE79C5FF69901;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1014941\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h5CEE79D6389C3B59;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h5CDE79D6389C3B58;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1015555\n");
-    end
-    x = 64'hC3FFFFFFFFFF8002;
-    y = 64'h43CF81FFFFFFFFFF;
-    z = 64'hC1F0FBFFFFFFFFFF;
-    ans = 64'hC7DF81FFFFFF81F9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1016169\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h8010000000000001;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1016783\n");
-    end
-    x = 64'h52B00007EFFFFFFE;
-    y = 64'hB80000020000003F;
-    z = 64'h8000000000000000;
-    ans = 64'hCAC00009F000FE3D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1017397\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hDB40000010003FFF;
-    ans = 64'hDB40000010003FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1018011\n");
-    end
-    x = 64'hAA1003FFFFFFFFBF;
-    y = 64'h400EFCB55B759507;
-    z = 64'h41E00100007FFFFF;
-    ans = 64'h41E00100007FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1018625\n");
-    end
-    x = 64'h3ACA98EA817AAD44;
-    y = 64'hBCA0000000000000;
-    z = 64'hC010000000000000;
+    ReadData1E = 64'hCBFFFFFFE1FFFFFE;
+    ReadData2E = 64'hAA2FFEFFFFFFEFFE;
+    ReadData3E = 64'hC010000000000000;
     ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1019239\n");
+    	$fwrite(fp,"952577\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h8762BBDF1A21B496;
-    z = 64'h3810000003FBFFFF;
-    ans = 64'h3810000003FBFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h3FE0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1019853\n");
+    	$fwrite(fp,"952883\n");
     end
-    x = 64'hBFF0000080008000;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'hCD6FF7FFFFFC0000;
-    ans = 64'hCD6FF7FFFFFC0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h8023F3F2A8389E11;
+    ReadData2E = 64'h066175AB575ABFB2;
+    ReadData3E = 64'h3FDFFFFFFFFC01FF;
+    ans = 64'h3FDFFFFFFFFC01FF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1020467\n");
+    	$fwrite(fp,"953189\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h4090000000000011;
-    z = 64'h3FD0000000000000;
-    ans = 64'h4080020000000010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h44468C671497C5ED;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1021081\n");
+    	$fwrite(fp,"953495\n");
     end
-    x = 64'hFFEFE00002000000;
-    y = 64'hBEAFEFFFFFFF7FFF;
-    z = 64'h41C1D04549226D33;
-    ans = 64'h7EAFD01001FE807F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FC4793378DC78BE;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'hC7FFF08000000000;
+    ans = 64'hC7FFF08000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1021695\n");
+    	$fwrite(fp,"953801\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hBFD0000000000000;
-    z = 64'hBFE0000000000000;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3FE1638DA0EC77C4;
+    ReadData3E = 64'hC1D0000100100000;
+    ans = 64'hC1D0000100074E39;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"954107\n");
+    end
+    ReadData1E = 64'hBB8FBFFEFFFFFFFF;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h3CB00000FDFFF7FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"954413\n");
+    end
+    ReadData1E = 64'hBFE78F372393823A;
+    ReadData2E = 64'h40284FEE9BB805EE;
+    ReadData3E = 64'h3801623519F16C3D;
+    ans = 64'hC021E642969DBD5D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"954719\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'h7FFEF9A73225A948;
+    ans = 64'h7FFEF9A73225A948;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"955025\n");
+    end
+    ReadData1E = 64'h3FCFF70000000000;
+    ReadData2E = 64'hFFE1112C9531B024;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'hFFC10C5FC0A7BA2A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"955331\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
     ans = 64'hBFE4000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1022309\n");
+    	$fwrite(fp,"955637\n");
     end
-    x = 64'hBFE0000003FDFFFF;
-    y = 64'hC00FFF7FFFF80000;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h9B800000200003FF;
+    ReadData2E = 64'hBFE014D6B151044F;
+    ReadData3E = 64'h3734B9CE039E32CB;
+    ans = 64'h3734B9CE039E32CB;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1022923\n");
+    	$fwrite(fp,"955943\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFF7F0;
-    ans = 64'h3FFBFFFFFFFFF7F0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1023537\n");
-    end
-    x = 64'h38FFFFFFFFFDFF7E;
-    y = 64'h9B8004000000000F;
-    z = 64'h2FDFFF8000000008;
-    ans = 64'h2FDFFF8000000008;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1024151\n");
-    end
-    x = 64'h3FE00001FFFEFFFF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'hC000000000000001;
-    ans = 64'hC00200003FFFE001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1024765\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hC1CFFF000FFFFFFE;
-    z = 64'h7FD8040000000000;
-    ans = 64'h7FD8040000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1025379\n");
-    end
-    x = 64'hC10FFFFFFFFFFEFE;
-    y = 64'hBFE0000000000001;
-    z = 64'hFFD0003F7FFFFFFF;
-    ans = 64'hFFD0003F7FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1025993\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h4B05E5A08426A286;
-    z = 64'h3CA0000000000001;
-    ans = 64'h4AF5E5A08426A285;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1026607\n");
-    end
-    x = 64'hF5E0000FFFF7FFFF;
-    y = 64'h4017BFFFFFFFFFFE;
-    z = 64'hBFB3A6B42E1910C4;
-    ans = 64'hF607C017BFF41FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1027221\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFE7FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1027835\n");
-    end
-    x = 64'h3FBFE00007FFFFFF;
-    y = 64'hC01FFFFFFFFE000F;
-    z = 64'h7FEFFFFFFFFFFFFF;
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC7EDFFFF7FFFFFFF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
     ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1028449\n");
+    	$fwrite(fp,"956249\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hBFF0000000000001;
-    z = 64'h3813A2BEB5826B36;
+    ReadData1E = 64'h3E401FFDFFFFFFFE;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'hBF8F80000000FFFF;
+    ans = 64'hBF8F80008100EFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"956555\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC1DFFEFFFFF7FFFF;
+    ReadData3E = 64'hDB300000000FFFBF;
+    ans = 64'hDB300000000FFFBF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"956861\n");
+    end
+    ReadData1E = 64'h47FE49AB039DFC52;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hC7EE49AB039DFC52;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"957167\n");
+    end
+    ReadData1E = 64'hC560FFFFFFFFFFBE;
+    ReadData2E = 64'hBFFFFFFFFFFFFFE2;
+    ReadData3E = 64'hC7FFBED86249373C;
+    ans = 64'hC7FFBED86249263C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"957473\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'hBFFD2C90EF0F0A69;
+    ans = 64'hBFFF2C90EF0F0A69;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"957779\n");
+    end
+    ReadData1E = 64'h489CCE60FE90D5B4;
+    ReadData2E = 64'hC1FDCD10BFBA3993;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hCAAAD3A117DA0724;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"958085\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'hBFCFFFFFFFFFFFF9;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"958391\n");
+    end
+    ReadData1E = 64'hB7F0008000000000;
+    ReadData2E = 64'hC01FFEFFDFFFFFFF;
+    ReadData3E = 64'h7FEFF8000000FFFE;
+    ans = 64'h7FEFF8000000FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"958697\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC03BC4DBCEA3AFEF;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC350000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"959003\n");
+    end
+    ReadData1E = 64'h401FFDFFFFF00000;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hC3400D15CAF2C5CA;
+    ans = 64'hC3400D15CAF2C5CE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"959309\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBFCFFFFE00007FFF;
+    ReadData3E = 64'hC1F0000003FFBFFF;
+    ans = 64'hC1F000000400BFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"959615\n");
+    end
+    ReadData1E = 64'hC100002000000000;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h4100002000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"959921\n");
+    end
+    ReadData1E = 64'hFFD800000007FFFE;
+    ReadData2E = 64'h3FD08000007FFFFE;
+    ReadData3E = 64'hB7F3784914F45A14;
+    ans = 64'hFFB8C00000C83FFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"960227\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'h002FFFBFFFFFFC00;
+    ans = 64'hBFD0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"960533\n");
+    end
+    ReadData1E = 64'h3FDFDFFFFFFFFFFD;
+    ReadData2E = 64'h8017FFFFEFFFFFFF;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'h3FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"960839\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hBFD0000000000004;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"961145\n");
+    end
+    ReadData1E = 64'h3960743905826A36;
+    ReadData2E = 64'hC02000001FFFFFEF;
+    ReadData3E = 64'hC0365E1AE8AC5C5E;
+    ans = 64'hC0365E1AE8AC5C5E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"961451\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC1CFFFFFFBFFFFBF;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h433FFFFFF0000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"961757\n");
+    end
+    ReadData1E = 64'h001B890A98279E8B;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h408F000000020000;
+    ans = 64'h408F000000020000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"962063\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hFFEFFFFFFFFFDFEE;
+    ReadData3E = 64'h3CF000000007FFF7;
+    ans = 64'hFFCFFFFFFFFFDFF0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"962369\n");
+    end
+    ReadData1E = 64'hBFCB62E6ED21BD63;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'h3FDB62E6ED21BD61;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"962675\n");
+    end
+    ReadData1E = 64'hC1E000000027FFFE;
+    ReadData2E = 64'h3FAFFFFEFFFFFF80;
+    ReadData3E = 64'hC02FFFFFFE007FFF;
+    ans = 64'hC19FFFFF404FFF76;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"962981\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'h4F40000400080000;
+    ans = 64'h4F40000400080000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"963287\n");
+    end
+    ReadData1E = 64'h381FFFFFEDFFFFFF;
+    ReadData2E = 64'hFFFFFFFE0000007F;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hFFFFFFFE0000007F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"963593\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'hBFE0000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"963899\n");
+    end
+    ReadData1E = 64'hBCA001FFFFDFFFFF;
+    ReadData2E = 64'h3FE2F2314E94F75E;
+    ReadData3E = 64'hBAEFFE0000000200;
+    ans = 64'hBC92F48F9898A599;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"964205\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h00171492F6962A8C;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC010000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"964511\n");
+    end
+    ReadData1E = 64'h800A1EC2F81DC219;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h37E6F1B7F6356355;
+    ans = 64'h37E6F1B7F6356355;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"964817\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h40A0000000800000;
+    ReadData3E = 64'hBFFDF4CAB0144EF1;
+    ans = 64'h407FE20B364FEBB3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"965123\n");
+    end
+    ReadData1E = 64'h7FF3BE7F51FBB158;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"965429\n");
+    end
+    ReadData1E = 64'h37F0000000014000;
+    ReadData2E = 64'h89066053EC882A36;
+    ReadData3E = 64'hC1B000000011FFFF;
+    ans = 64'hC1B000000011FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"965735\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'hC1CFFFFFFFFF8007;
+    ans = 64'hC1D00000003FC003;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"966041\n");
+    end
+    ReadData1E = 64'hC2CFFFFFFFFFDFC0;
+    ReadData2E = 64'hC3F01FFFFFFFFFF6;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'h46D01FFFFFFFEFB6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"966347\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'hBFF0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"966653\n");
+    end
+    ReadData1E = 64'h4E3FFC01FFFFFFFF;
+    ReadData2E = 64'h62E1FFFEFFFFFFFE;
+    ReadData3E = 64'h3FDFFFFFFC00007F;
+    ans = 64'h7131FDC0201FEFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"966959\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBFDFFF8000000080;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h400F0003FFFFFFFB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"967265\n");
+    end
+    ReadData1E = 64'hC13000001DFFFFFF;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'hC000001FFFFFFFF0;
+    ans = 64'h414FFFFF3BFE0000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"967571\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3253FDFFFFFFFFFF;
+    ReadData3E = 64'hBCA1FFFFFFFFE000;
+    ans = 64'hBCA1FFFFFFFFE000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"967877\n");
+    end
+    ReadData1E = 64'h7FD00400000001FF;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"968183\n");
+    end
+    ReadData1E = 64'h5C2AC90B8977039C;
+    ReadData2E = 64'hBCA0000FFFFFFDFF;
+    ReadData3E = 64'hC0CFFFFFFFFE7FFF;
+    ans = 64'hD8DAC926528289B8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"968489\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'hFFDFFFC001FFFFFF;
+    ans = 64'hFFDFFFC001FFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"968795\n");
+    end
+    ReadData1E = 64'h47E1FEFFFFFFFFFE;
+    ReadData2E = 64'hBFF0041000000000;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hC7E20391BEFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"969101\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"969407\n");
+    end
+    ReadData1E = 64'hFFF0000400000000;
+    ReadData2E = 64'h78400000000FFDFF;
+    ReadData3E = 64'hC1F36615D549A0E5;
+    ans = 64'hFFF8000400000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"969713\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC006A045CF961FE9;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hC005A81173E587FA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"970019\n");
+    end
+    ReadData1E = 64'hC1E20FFFFFFFFFFF;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'h3FC03FFFFFF80000;
+    ans = 64'h4532100000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"970325\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC1FFDFFF7FFFFFFE;
+    ReadData3E = 64'hBFDDFFFFEFFFFFFF;
+    ans = 64'hC1DFDFFF801E0000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"970631\n");
+    end
+    ReadData1E = 64'hC80A1EC7C632AD61;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"970937\n");
+    end
+    ReadData1E = 64'hEEEDFBFFFFFFFFFE;
+    ReadData2E = 64'hC3F07FFFBFFFFFFE;
+    ReadData3E = 64'h3FFA5202B857DE26;
+    ans = 64'h72EEEBDF880FFFFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"971243\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'hC00FFFFFF8000003;
+    ans = 64'hC330000000000004;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"971549\n");
+    end
+    ReadData1E = 64'h41F63343608D9BC4;
+    ReadData2E = 64'h51FBCA96E92C466E;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h540347CD24D8C7DD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"971855\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"972161\n");
+    end
+    ReadData1E = 64'h9AECFD35BA2EEEA1;
+    ReadData2E = 64'h45E0000080003FFF;
+    ReadData3E = 64'hBFEFFFFFFFBFF7FF;
+    ans = 64'hBFEFFFFFFFBFF7FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"972467\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h594FF80000000010;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h592FF80000000012;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"972773\n");
+    end
+    ReadData1E = 64'h0000008FFFFFFFFE;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'hC055969B9E03C347;
+    ans = 64'hC05596A01E03C347;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"973079\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h43DFE000000003FF;
+    ReadData3E = 64'h47EFFFFEFFF80000;
+    ans = 64'h47EFFFFEFFF80000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"973385\n");
+    end
+    ReadData1E = 64'h287FEFFEFFFFFFFF;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'hE86FEFFF00000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"973691\n");
+    end
+    ReadData1E = 64'hC3E800000000003F;
+    ReadData2E = 64'h802E7EFB0F9DFB33;
+    ReadData3E = 64'hC01FFFFFFFFFFFE7;
+    ans = 64'hC01FFFFFFFFFFFE7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"973997\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hEC7FFFBFFBFFFFFF;
+    ans = 64'hFFD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"974303\n");
+    end
+    ReadData1E = 64'h3CE000003FFEFFFF;
+    ReadData2E = 64'hC130040003FFFFFE;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'hBE200400440EFFCD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"974609\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"974915\n");
+    end
+    ReadData1E = 64'hC00DFFBFFFFFFFFF;
+    ReadData2E = 64'hC075E9323CB1786B;
+    ReadData3E = 64'hC008AD1C6219D7C3;
+    ans = 64'h40947E1CB850DA95;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"975221\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBF6FF8000000007F;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'hBFE007FE00000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"975527\n");
+    end
+    ReadData1E = 64'h69CC4C2584E45E21;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'h26CA7C0E0EDC5D70;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"975833\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'h3FE8720FB6B51807;
+    ReadData3E = 64'hBFC000007EFFFFFF;
+    ans = 64'h3FB0E41E6F6A3013;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"976139\n");
+    end
+    ReadData1E = 64'hC3F37CDA8E6B566C;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"976445\n");
+    end
+    ReadData1E = 64'hFFD21FFFFFFFFFFE;
+    ReadData2E = 64'hB810000001FEFFFE;
+    ReadData3E = 64'hC80FFFFFFFA00000;
+    ans = 64'h77F220000242DDFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"976751\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'hC34000000003F000;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"977057\n");
+    end
+    ReadData1E = 64'h381FFFF7FF7FFFFF;
+    ReadData2E = 64'hE60A593DE76F061F;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'hDE3A593750B6274B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"977363\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"977669\n");
+    end
+    ReadData1E = 64'hBFE5C55F9D983738;
+    ReadData2E = 64'hBFE0003FFFFDFFFE;
+    ReadData3E = 64'h3D4D4C7C8BA68069;
+    ans = 64'h3FD5C5B6B3140390;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"977975\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hC3EFFFFFFFFFB7FF;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'hC3CFFFFFFFFFB801;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"978281\n");
+    end
+    ReadData1E = 64'h4023A84702311282;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h4018B473E74D3CF2;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"978587\n");
+    end
+    ReadData1E = 64'h3FD0000000000001;
+    ReadData2E = 64'hBF3000010000007E;
+    ReadData3E = 64'hBFFFFFFFFFFFF802;
+    ans = 64'hC00000200001FC01;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"978893\n");
+    end
+    ReadData1E = 64'hFFEFFFFFFEFDFFFF;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"979199\n");
+    end
+    ReadData1E = 64'h3C300000FFFFF7FF;
+    ReadData2E = 64'hC2BFFF0000000004;
+    ReadData3E = 64'hBFCBFB075CA1326A;
+    ans = 64'hBFCBFC0754B131EA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"979505\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'h41AFFFFFFC0001FE;
+    ans = 64'h41AFFFFFFC0001FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"979811\n");
+    end
+    ReadData1E = 64'h40FFFFFFFFFFF03E;
+    ReadData2E = 64'hBCAFFFFFF5FFFFFF;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"980117\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hC01FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"980423\n");
+    end
+    ReadData1E = 64'h401FFFBFFFFFFF7F;
+    ReadData2E = 64'hC00C00000000007E;
+    ReadData3E = 64'hBEBFFFFF0000FFFE;
+    ans = 64'hC03BFFC81FFFFF0D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"980729\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBF8BFFFF80000000;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'hBF7BFFFF800000FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"981035\n");
+    end
+    ReadData1E = 64'h3D10000000004004;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h3CA8781265FFCFE7;
+    ans = 64'h3CA8781265FFCFE7;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"981341\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FD6B45300124B28;
+    ReadData3E = 64'h47E7FFFFF7FFFFFE;
+    ans = 64'h47E7FFFFF7FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"981647\n");
+    end
+    ReadData1E = 64'hB7EFFFEFFDFFFFFE;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"981953\n");
+    end
+    ReadData1E = 64'hFFFFFFFFFFC3FFFF;
+    ReadData2E = 64'h3F900000A0000000;
+    ReadData3E = 64'h41E000000083FFFF;
+    ans = 64'hFFFFFFFFFFC3FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"982259\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h0010000000000000;
+    ReadData3E = 64'h3F8F001000000000;
+    ans = 64'h3F8F001000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"982565\n");
+    end
+    ReadData1E = 64'h8020000000001FFC;
+    ReadData2E = 64'hBC0FFFF9FFFFFFFE;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
+    ans = 64'hFFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"982871\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'h4010000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"983177\n");
+    end
+    ReadData1E = 64'hC34626B788D750F2;
+    ReadData2E = 64'h381FFFBFFFFFFDFE;
+    ReadData3E = 64'h3FB00080001FFFFF;
+    ans = 64'h3FB00080001FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"983483\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC01F780000000000;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'hC00F77FFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"983789\n");
+    end
+    ReadData1E = 64'h121FFFFFFC000002;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'h40300003FFFF7FFF;
+    ans = 64'h40300003FFFF7FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"984095\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3F400000001FFFDE;
+    ReadData3E = 64'h8029A783715CE4CD;
+    ans = 64'h3F300000001FFFDD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"984401\n");
+    end
+    ReadData1E = 64'hFFE000040003FFFF;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'hC00000080007FFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"984707\n");
+    end
+    ReadData1E = 64'h380FFFFC007FFFFE;
+    ReadData2E = 64'h6A9FFFC000000003;
+    ReadData3E = 64'h8012C39F78579516;
+    ans = 64'h62BFFFBC0087FF01;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"985013\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'hBCAFDFFFFFFFFFEE;
+    ans = 64'hBCA7DFFFFFFFFFEE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"985319\n");
+    end
+    ReadData1E = 64'h41AFFFFF8001FFFE;
+    ReadData2E = 64'h2C6BBA796AEC3BE5;
+    ReadData3E = 64'h7FE0000000000000;
+    ans = 64'h7FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"985625\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC000000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"985931\n");
+    end
+    ReadData1E = 64'hFFD8BB98BFC10007;
+    ReadData2E = 64'h41EFFFFEFFFFF800;
+    ReadData3E = 64'h37E00000000FFFF8;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"986237\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3ECFFFFFBFFFE000;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h3EBFFFFFBFFFDFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"986543\n");
+    end
+    ReadData1E = 64'h47E0040FFFFFFFFF;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'hB04007FFFFFFFF7F;
+    ans = 64'h4490041000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"986849\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h21000001003FFFFE;
+    ReadData3E = 64'h3CA5394998BC9A57;
+    ans = 64'h3CA5394998BC9A57;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"987155\n");
+    end
+    ReadData1E = 64'h31BFFFFFFFC0003F;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hBFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"987461\n");
+    end
+    ReadData1E = 64'h44A367D1A38248BF;
+    ReadData2E = 64'hDD3DC9E8AED9E5B2;
+    ReadData3E = 64'hBD000FFFFFFFFEFF;
+    ans = 64'hE1F2108733B1A4F0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"987767\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFE;
+    ReadData3E = 64'hC1F000000080003E;
+    ans = 64'hC1F000000080003E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"988073\n");
+    end
+    ReadData1E = 64'h9C09F2FB6E1B6AC0;
+    ReadData2E = 64'hA7D718808707F875;
+    ReadData3E = 64'hC340000000000001;
+    ans = 64'hC340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"988379\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h4000FFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"988685\n");
+    end
+    ReadData1E = 64'hB80FFFFFC007FFFF;
+    ReadData2E = 64'hFDFFFFFFE7FFFFFF;
+    ReadData3E = 64'hC1EFFFF7FFEFFFFF;
+    ans = 64'h761FFFFFA808002E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"988991\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h40100000000FFFFE;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h40000000000FFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"989297\n");
+    end
+    ReadData1E = 64'hC0F0E9718D9CDCE9;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'hC01FFFFFFFFFFEFD;
+    ans = 64'hC0D0EB718D9CDCEA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"989603\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FC01FFFFFFFFFEF;
+    ReadData3E = 64'hCCC916E161AACEEE;
+    ans = 64'hCCC916E161AACEEE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"989909\n");
+    end
+    ReadData1E = 64'hBF137F0147CBDE6D;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h3FDFFF6407F5C1A1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"990215\n");
+    end
+    ReadData1E = 64'hC1F03FFFF7FFFFFF;
+    ReadData2E = 64'hC3F0001F7FFFFFFE;
+    ReadData3E = 64'hC7E5B399E0BBB6AA;
+    ans = 64'hC7E5B399E09B366A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"990521\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'h41D200000000FFFF;
+    ans = 64'h41D200000010FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"990827\n");
+    end
+    ReadData1E = 64'hC1B0EE7ED613B6E0;
+    ReadData2E = 64'hC3F0504B43F10D03;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'h45B14376F61A6E2B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"991133\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hBFE7FFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"991439\n");
+    end
+    ReadData1E = 64'h4068B9229919C3B2;
+    ReadData2E = 64'hC1F9CD735BDB5221;
+    ReadData3E = 64'h3BF8F8569B788D11;
+    ans = 64'hC273EF5E2D8D3101;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"991745\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h43EFE0000FFFFFFF;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"992051\n");
+    end
+    ReadData1E = 64'hC3C0000000003FBF;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'hBD0FFFFFFFFFC001;
+    ans = 64'hC3B0000000003FBF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"992357\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFF00000001FFFFD;
+    ReadData3E = 64'h43400000000FDFFF;
+    ans = 64'h43400000000FDFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"992663\n");
+    end
+    ReadData1E = 64'h4021FFFEFFFFFFFF;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'h4010FFFF00000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"992969\n");
+    end
+    ReadData1E = 64'h3FD43A64D1B392BB;
+    ReadData2E = 64'h40A2000000400000;
+    ReadData3E = 64'h3FCFF00FFFFFFFFE;
+    ans = 64'h4086C3B06D3AEEA6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"993275\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FB0008000002000;
+    ans = 64'h3FE20010000003FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"993581\n");
+    end
+    ReadData1E = 64'hBFEFFFFEFFFFFFDF;
+    ReadData2E = 64'h47F0000001C00000;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hC7EFFFFF037FFFC3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"993887\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h3FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"994193\n");
+    end
+    ReadData1E = 64'h47F400000000001E;
+    ReadData2E = 64'h403D60E42520C790;
+    ReadData3E = 64'h5FFFFFFFBFFFFFEE;
+    ans = 64'h5FFFFFFFBFFFFFEE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"994499\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h8D2FFFFFFFFF7F00;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"994805\n");
+    end
+    ReadData1E = 64'hBE7FFFFFF0000080;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'hBFEFD6F62F0019CE;
+    ans = 64'hBFEFD6F66F0019AE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"995111\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h406F7FFFFFDFFFFE;
+    ReadData3E = 64'h3FF91C0E0D8CFD19;
+    ans = 64'h405FE470381633F1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"995417\n");
+    end
+    ReadData1E = 64'hC7EFFC001FFFFFFE;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'hC7EFFC0020000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"995723\n");
+    end
+    ReadData1E = 64'h409FFEFBFFFFFFFF;
+    ReadData2E = 64'h47E0003FFF7FFFFE;
+    ReadData3E = 64'h0020000FFFFFFFFB;
+    ans = 64'h488FFF7BFAF0081B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"996029\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'hB9500000002007FF;
+    ans = 64'h3FE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"996335\n");
+    end
+    ReadData1E = 64'h0021FBFFFFFFFFFE;
+    ReadData2E = 64'hD2657E7C804AB0C5;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'h4000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"996641\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'h3FE7FFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"996947\n");
+    end
+    ReadData1E = 64'hC3E020001FFFFFFE;
+    ReadData2E = 64'hC01800000007FFFF;
+    ReadData3E = 64'hC1FFFFF7FFFFFFDF;
+    ans = 64'h440830002FF81000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"997253\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBA4FFFFFF0003FFF;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"997559\n");
+    end
+    ReadData1E = 64'h3FC23813383D12F2;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'hC01000001FF00000;
+    ans = 64'hC00DB8FDD8D85DA2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"997865\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hB810DF99665D6F69;
+    ReadData3E = 64'h43F0000800100000;
+    ans = 64'h43F0000800100000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"998171\n");
+    end
+    ReadData1E = 64'h3FF1A6FD72CBC7F4;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'h4001A6FD72CBC7F4;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"998477\n");
+    end
+    ReadData1E = 64'h40040000003FFFFF;
+    ReadData2E = 64'h3FDFFFBFFFFE0000;
+    ReadData3E = 64'h3FFFFFFFFC000001;
+    ans = 64'h4009FFEBFE1F5FC0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"998783\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'hBFCFFFFEFF000000;
+    ans = 64'h3FE8000040400001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"999089\n");
+    end
+    ReadData1E = 64'hC34F85E5C3567603;
+    ReadData2E = 64'hC1D000000080FFFF;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'h452F85E5C4549D8D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"999395\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'h3FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"999701\n");
+    end
+    ReadData1E = 64'h37EFFFFF00000003;
+    ReadData2E = 64'h5E90000001BFFFFE;
+    ReadData3E = 64'h47F0000020000002;
+    ans = 64'h568FFFFF037FFFE3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1000007\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h41C609CDCAAE88A3;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFF4FB191A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1000313\n");
+    end
+    ReadData1E = 64'hC060008000FFFFFF;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'h25C2C89884490777;
+    ans = 64'hC080008000FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1000619\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC3DC007FFFFFFFFF;
+    ReadData3E = 64'h00032CA7CDBDDF36;
+    ans = 64'hC3CC007FFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1000925\n");
+    end
+    ReadData1E = 64'h802FFFFFE0040000;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'h804DFFFFE0040000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1001231\n");
+    end
+    ReadData1E = 64'hB80C07FFFFFFFFFE;
+    ReadData2E = 64'hBFE800000000003F;
+    ReadData3E = 64'h40241C223A4D9841;
+    ans = 64'h40241C223A4D9841;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1001537\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'h40000007FFFFC000;
+    ans = 64'h40100003FFFFE000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1001843\n");
+    end
+    ReadData1E = 64'hC000000000BFFFFE;
+    ReadData2E = 64'hB7FFFFDFFFFBFFFE;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h3FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1002149\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'h4000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1002455\n");
+    end
+    ReadData1E = 64'hC03FFFFF7FFC0000;
+    ReadData2E = 64'h380FFFFFFFFFF807;
+    ReadData3E = 64'h40479C03BA46E5FF;
+    ans = 64'h40479C03BA46E5FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1002761\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC0105FFFFFFFFFFF;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h4017CFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1003067\n");
+    end
+    ReadData1E = 64'h32A659D12B3A57E2;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'hC0501FFE00000000;
+    ans = 64'hC0501FFE00000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1003373\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC3E0207FFFFFFFFF;
+    ReadData3E = 64'h402003FFFFFFFFDE;
+    ans = 64'hC3D0207FFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1003679\n");
+    end
+    ReadData1E = 64'h381FFFFBFFEFFFFF;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h384FFFFBFFEFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1003985\n");
+    end
+    ReadData1E = 64'h3B50000080000040;
+    ReadData2E = 64'h43CFFFE003FFFFFF;
+    ReadData3E = 64'hC1DFFFFFDFFFFEFF;
+    ans = 64'hC1DFFFFFDFFFFAFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1004291\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'hC0210341F15BAF08;
+    ans = 64'h432FFFFFFFFFFFEE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1004597\n");
+    end
+    ReadData1E = 64'hFFD00007FFFFE000;
+    ReadData2E = 64'h4040010000200000;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1004903\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'h4330000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1005209\n");
+    end
+    ReadData1E = 64'h115FFBFFFFFC0000;
+    ReadData2E = 64'h3F3FFFFFBFFF8000;
+    ReadData3E = 64'hFFDBFFFFEFFFFFFF;
+    ans = 64'hFFDBFFFFEFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1005515\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC035395F6673F88F;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC02D395F6673F88E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1005821\n");
+    end
+    ReadData1E = 64'h002FFC00FFFFFFFF;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'h00198167B6DD2E02;
+    ans = 64'h038FFC00FFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1006127\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFFE0B95ECD9ACF7;
+    ReadData3E = 64'h3FD0000080000007;
+    ans = 64'hBFE60B95ACD9ACF3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1006433\n");
+    end
+    ReadData1E = 64'h4806C87C6E9AD566;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1006739\n");
+    end
+    ReadData1E = 64'hC019E1FC6C077592;
+    ReadData2E = 64'h3CAC9006ED57E4C3;
+    ReadData3E = 64'h40100007FFFFBFFE;
+    ans = 64'h40100007FFFFBFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1007045\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFEFFFFFEFFEFFFF;
+    ans = 64'h433FFFFFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1007351\n");
+    end
+    ReadData1E = 64'h3D2666AE90703854;
+    ReadData2E = 64'hBC30FFFFFFFF7FFE;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h3FD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1007657\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'h7FCFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1007963\n");
+    end
+    ReadData1E = 64'h7FF78D4C8A6F6B33;
+    ReadData2E = 64'h1EEF6DBA3B66A8C5;
+    ReadData3E = 64'hC12FFDFBFFFFFFFF;
+    ans = 64'h7FFF8D4C8A6F6B33;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1008269\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h4340000010000020;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'h4330000010000021;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1008575\n");
+    end
+    ReadData1E = 64'h3FC07FFF7FFFFFFE;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'hC3E631875CDB7E45;
+    ans = 64'h7FB07FFF7FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1008881\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBF2000001FFBFFFE;
+    ReadData3E = 64'h43E0000012000000;
+    ans = 64'h43E0000012000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1009187\n");
+    end
+    ReadData1E = 64'h3FD45A9AEEFFF3C6;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1009493\n");
+    end
+    ReadData1E = 64'hBED003FFC0000000;
+    ReadData2E = 64'hC00FFDFFFFFEFFFE;
+    ReadData3E = 64'hBF4FFFFFFBFFFFF7;
+    ans = 64'hBF4F7FE7FFFFE3F8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1009799\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FB7FFE000000000;
+    ans = 64'h7FDFFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1010105\n");
+    end
+    ReadData1E = 64'h3F3FFFFFFDFFFFFE;
+    ReadData2E = 64'hB81FFF0000FFFFFE;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hBCA0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1010411\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1010717\n");
+    end
+    ReadData1E = 64'h8FFC99FE1EB38741;
+    ReadData2E = 64'hC1EFFEBFFFFFFFFF;
+    ReadData3E = 64'h43C000200003FFFE;
+    ans = 64'h43C000200003FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1011023\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFEFFFFFC2000000;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hC003FFFFF83FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1011329\n");
+    end
+    ReadData1E = 64'hC070000000FFBFFF;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'hC1C6E2D6423AD7C0;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1011635\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h4060020007FFFFFF;
+    ReadData3E = 64'hBFCFEFBFFFFFFFFF;
+    ans = 64'h404FE4104FFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1011941\n");
+    end
+    ReadData1E = 64'h80222D75B3139904;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1012247\n");
+    end
+    ReadData1E = 64'hC7F478EFD91BB2AE;
+    ReadData2E = 64'h24B0000000080006;
+    ReadData3E = 64'h7FDFFFFFFFFDFFEE;
+    ans = 64'h7FDFFFFFFFFDFFEE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1012553\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h2B8FFFFFFFFF83FE;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1012859\n");
+    end
+    ReadData1E = 64'h7FDFFFFFFFFF5FFF;
+    ReadData2E = 64'h401FFF8000000001;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1013165\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1013471\n");
+    end
+    ReadData1E = 64'hBFC92B62A147BA62;
+    ReadData2E = 64'hC10FF800000000FF;
+    ReadData3E = 64'h3FCFFDFFFFFC0000;
+    ans = 64'h40E9251FC81F693B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1013777\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h434FFFEFFFFBFFFE;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'h433FFFEFFFFBFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1014083\n");
+    end
+    ReadData1E = 64'hBF7FEFFFEFFFFFFE;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'hC0EFFFFFFFF9FFFF;
+    ans = 64'hC0EFFFFFFFF9FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1014389\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFE581C023E170BC;
+    ReadData3E = 64'hFFF000003FBFFFFF;
+    ans = 64'hFFF800003FBFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1014695\n");
+    end
+    ReadData1E = 64'hC00DC00000000000;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1015001\n");
+    end
+    ReadData1E = 64'h4800000080000000;
+    ReadData2E = 64'h381C5A57C936F7B7;
+    ReadData3E = 64'h4808000000000FFE;
+    ans = 64'h4808000000000FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1015307\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'h3CA0000FFFF7FFFF;
+    ans = 64'h3CA0000FFFF7FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1015613\n");
+    end
+    ReadData1E = 64'hBFEFFFFFBFFFDFFF;
+    ReadData2E = 64'hBFEFFF000FFFFFFF;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'h3FEFFEFFD001DFDF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1015919\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1016225\n");
+    end
+    ReadData1E = 64'h3940000014000000;
+    ReadData2E = 64'h001FFFBFFFFFFFFF;
+    ReadData3E = 64'hB95FFFFFC003FFFF;
+    ans = 64'hB95FFFFFC003FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1016531\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h8ADFFFFFF000000F;
+    ReadData3E = 64'hBFE0000000000000;
     ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1029063\n");
+    	$fwrite(fp,"1016837\n");
     end
-    x = 64'h3D7FFFFFFFFDFFFD;
-    y = 64'hBF1A0514D4BED171;
-    z = 64'h401FA4D562334CE0;
-    ans = 64'h401FA4D562334CE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h406DF9FFE3D019C9;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'h41C0000000007EFF;
+    ans = 64'h41C0000000007EFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1029677\n");
+    	$fwrite(fp,"1017143\n");
     end
-    x = 64'hA720000FFE000000;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h43CFFFFFFFFFFBFF;
+    ReadData3E = 64'h4000040001FFFFFE;
+    ans = 64'h43BFFFFFFFFFFBFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1030291\n");
+    	$fwrite(fp,"1017449\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hBF950025543D3C42;
-    z = 64'hBFDB40EC8C50107B;
-    ans = 64'hBFDBE8EDB6F1FA5D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hCE8FFFFFFFFFFFE8;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1030905\n");
+    	$fwrite(fp,"1017755\n");
     end
-    x = 64'hBFEF000004000000;
-    y = 64'hC000000000000000;
-    z = 64'hC34FF80000000006;
-    ans = 64'hC34FF80000000005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h0960000800100000;
+    ReadData2E = 64'h403FFC0001000000;
+    ReadData3E = 64'h41D7FFFFFFFFFFC0;
+    ans = 64'h41D7FFFFFFFFFFC0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1031519\n");
+    	$fwrite(fp,"1018061\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h43EBFFFFFF800000;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h43DBFFFFFF7FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'hC1FFFFFFE0003FFF;
+    ans = 64'hC1FFFFFFE0003FFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1032133\n");
+    	$fwrite(fp,"1018367\n");
     end
-    x = 64'h3E2400000000000F;
-    y = 64'h43F03213356F2EC0;
-    z = 64'h01B2E18AE3758A2A;
-    ans = 64'h42243E9802CAFA7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h410FFFF7FDFFFFFE;
+    ReadData2E = 64'h480BFFFFC0000000;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'h492BFFF8BE401002;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1032747\n");
+    	$fwrite(fp,"1018673\n");
     end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1018979\n");
+    end
+    ReadData1E = 64'h43EFDF7FFFFFFFFF;
+    ReadData2E = 64'hB7E0001007FFFFFF;
+    ReadData3E = 64'hB4C000201FFFFFFF;
+    ans = 64'hBBDFDF9FEF6FBFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1019285\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC1DFFFFFFFFEFDFE;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'hC1CFFFFFFFDEFDFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1019591\n");
+    end
+    ReadData1E = 64'hC080000000201000;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'h41CFFDFFFFFFFFFE;
+    ans = 64'h41CFFDFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1019897\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFF0100000000002;
+    ReadData3E = 64'hBF9FDFFFEFFFFFFF;
+    ans = 64'hFFF8100000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1020203\n");
+    end
+    ReadData1E = 64'h480FFFFFE00003FF;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'hC4BFFFFFE00003FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1020509\n");
+    end
+    ReadData1E = 64'h43DD2781CF9BF717;
+    ReadData2E = 64'hBFB1000000000006;
+    ReadData3E = 64'hB7E0000000001FDF;
+    ans = 64'hC39EF9F9EC95B693;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1020815\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'h37E0041FFFFFFFFF;
+    ans = 64'hBC90000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1021121\n");
+    end
+    ReadData1E = 64'h4AA000000003FFF0;
+    ReadData2E = 64'hBFFFFFFFFFEFFC00;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1021427\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1021733\n");
+    end
+    ReadData1E = 64'h4010000008000001;
+    ReadData2E = 64'h3FD00FFF00000000;
+    ReadData3E = 64'hBFC000400000007E;
+    ans = 64'h3FEC1FEE100FFEE3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1022039\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h472FC0003FFFFFFF;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'h471FC0003FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1022345\n");
+    end
+    ReadData1E = 64'hC80FFFFFBFFFFFDF;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'h798FFF0040000000;
+    ans = 64'h798FFF0040000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1022651\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hB400E44229C276B0;
+    ReadData3E = 64'h403020001FFFFFFF;
+    ans = 64'h403020001FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1022957\n");
+    end
+    ReadData1E = 64'hB48784AE13E55D35;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hC000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1023263\n");
+    end
+    ReadData1E = 64'h4340000001FFFFFE;
+    ReadData2E = 64'hC1F07FFFFFFF7FFE;
+    ReadData3E = 64'hC3F1FFFFFFFEFFFF;
+    ans = 64'hC5408000920F7FFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1023569\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFD0000000000000;
+    ReadData3E = 64'h42B0000002100000;
+    ans = 64'h42B00000020FFFE0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1023875\n");
+    end
+    ReadData1E = 64'hCE71FFFFFFFFFFFB;
+    ReadData2E = 64'h9B2FFFFFFFFFFF6E;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1024181\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'h400EFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1024487\n");
+    end
+    ReadData1E = 64'hC194000000001000;
+    ReadData2E = 64'h43B496260249CFD3;
+    ReadData3E = 64'h400FEFFFFDFFFFFE;
+    ans = 64'hC559BBAF82DC585E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1024793\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h5C6B01BA6B0ECB17;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h5C5B01BA6B0ECB16;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1025099\n");
+    end
+    ReadData1E = 64'hBFF0000000001002;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'h30A0000FFFFFFF7F;
+    ans = 64'h3FE0000000001001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1025405\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h4080000000FFFFC0;
+    ReadData3E = 64'h37EFE0007FFFFFFF;
+    ans = 64'h4070000000FFFFBF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1025711\n");
+    end
+    ReadData1E = 64'hBFC4195BFCEF85E3;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h3FF14195BFCEF85F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1026017\n");
+    end
+    ReadData1E = 64'hFFDFFFFFFFFFF7DE;
+    ReadData2E = 64'hC3CFFFFFFFBFF7FE;
+    ReadData3E = 64'hC03FFFFF003FFFFE;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1026323\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'h434D28185A46B2EB;
+    ans = 64'h434D28185A46B2EB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1026629\n");
+    end
+    ReadData1E = 64'hB8DFFFFFFFF00010;
+    ReadData2E = 64'h3C8FEFDFFFFFFFFE;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h434FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1026935\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hC002000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1027241\n");
+    end
+    ReadData1E = 64'h8D1CB6E31C42D6D0;
+    ReadData2E = 64'h4026B2B4559344C6;
+    ReadData3E = 64'hC7EFFCFFFFFFFFFF;
+    ans = 64'hC7EFFCFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1027547\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h3FDFFFF801FFFFFF;
+    ReadData3E = 64'h8010000000000000;
+    ans = 64'h3FCFFFF801FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1027853\n");
+    end
+    ReadData1E = 64'hC028000001FFFFFF;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'h41EFC00020000000;
+    ans = 64'h41EFC00020C00000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1028159\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC3EFFFFFFBFFFFFF;
+    ReadData3E = 64'hC3D8697088B915AB;
+    ans = 64'hC3EC34B8425C8AD5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1028465\n");
+    end
+    ReadData1E = 64'h407C66F7D3FB5A4F;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hC07C76F7D3FB5A4E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1028771\n");
+    end
+    ReadData1E = 64'hBFC937040830C79E;
+    ReadData2E = 64'hBFBFFE0100000000;
+    ReadData3E = 64'hBE3FFFFF7FFF7FFF;
+    ans = 64'h3F993570E1A866D3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1029077\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBF4FFFFFFFFC03FF;
+    ans = 64'hBFE007FFFFFFFEFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1029383\n");
+    end
+    ReadData1E = 64'h416FFFFEFFF7FFFE;
+    ReadData2E = 64'h3FE0000008000002;
+    ReadData3E = 64'hC340000000000000;
+    ans = 64'hC33FFFFFFF800004;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1029689\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'h3FF0000000000001;
+    ans = 64'h3FE0000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1029995\n");
+    end
+    ReadData1E = 64'h7FFFFFF0FFFFFFFF;
+    ReadData2E = 64'hBF6000000FFFFFFE;
+    ReadData3E = 64'h3E9F8F47F01A6A7B;
+    ans = 64'h7FFFFFF0FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1030301\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h380DACDF6E0D7A8D;
+    ReadData3E = 64'h0000000000000001;
+    ans = 64'h37FDACDF6E0D7A8C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1030607\n");
+    end
+    ReadData1E = 64'h401FE148734D4B74;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'h281FFFF00000000E;
+    ans = 64'hC01FE148734D4B76;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1030913\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h41E0000FFFFFFFBF;
+    ReadData3E = 64'hFFD88149181B8BAA;
+    ans = 64'hFFD88149181B8BAA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1031219\n");
+    end
+    ReadData1E = 64'hC08250FEC0C6C7E6;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'h409252FEC0C6C7E5;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1031525\n");
+    end
+    ReadData1E = 64'h432EE7DCB359DC6B;
+    ReadData2E = 64'h40B074A36C4386CA;
+    ReadData3E = 64'hBFFFFFE0007FFFFE;
+    ans = 64'h43EFC9295EA60C0F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1031831\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h400FFEFFFFFEFFFE;
+    ans = 64'h4007FEFFFFFEFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1032137\n");
+    end
+    ReadData1E = 64'hC343B1E8463B2B26;
+    ReadData2E = 64'h7FF007FFFFFF7FFF;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h7FF807FFFFFF7FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1032443\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFF;
+    ans = 64'hBFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1032749\n");
+    end
+    ReadData1E = 64'h40190979C4E0CA3F;
+    ReadData2E = 64'hBFE000001001FFFE;
+    ReadData3E = 64'hBCBBFFFFFFFFFFFC;
+    ans = 64'hC0090979DDED6531;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1033055\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h825FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFF;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
@@ -79140,234676 +131731,11003 @@ initial
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
     	$fwrite(fp,"1033361\n");
     end
-    x = 64'hC7E00FFFFEFFFFFE;
-    y = 64'hA0FFFFF80000007E;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC7F07F7FFFFFFFFF;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'h41EFFFFFEFFFFFF8;
+    ans = 64'h48007F7FFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1033975\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hC010000000000000;
-    z = 64'h41CE0FFFFFFFFFFF;
-    ans = 64'h41CE0FFFFEFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1034589\n");
-    end
-    x = 64'hBFE001000001FFFE;
-    y = 64'h41C0400000040000;
-    z = 64'hBDAF0000000001FF;
-    ans = 64'hC1B041040006083E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1035203\n");
-    end
-    x = 64'h48000000001FBFFF;
-    y = 64'hC010000000000001;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hC8200000001FC000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1035817\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hC3F00FFFFBFFFFFE;
-    z = 64'hC1EFF80000200000;
-    ans = 64'hC3E00FFFFC1FF7FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1036431\n");
-    end
-    x = 64'hC1D0001000000020;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hBFFFFFFE000001FF;
-    ans = 64'h4200000FFFF00020;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1037045\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hA3700000000FFFBF;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'hA3600000000FFFBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1037659\n");
-    end
-    x = 64'hA68BFDFFFFFFFFFF;
-    y = 64'h43FFFFFFE000003F;
-    z = 64'hFFDFF7FFFFFC0000;
-    ans = 64'hFFDFF7FFFFFC0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1038273\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hC340000000000001;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'hC330000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1038887\n");
-    end
-    x = 64'hBFE0010000007FFF;
-    y = 64'h3FF00003FFFFFF7F;
-    z = 64'h4340000000000000;
-    ans = 64'h433FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1039501\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h37E57439B2172858;
-    ans = 64'hC33FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1040115\n");
-    end
-    x = 64'h479FFFFF0FFFFFFF;
-    y = 64'hBCAFFF7FFFFFFFFE;
-    z = 64'h3FF11E1E3AE7A649;
-    ans = 64'hC45FFF7F1003BFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1040729\n");
-    end
-    x = 64'h7FD00FFFFFFF0000;
-    y = 64'hFFE0000000000000;
-    z = 64'hBFE0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1041343\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hDF70080000000006;
-    z = 64'hC3400000FFFF0000;
-    ans = 64'hDF60080000000005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1041957\n");
-    end
-    x = 64'hC034D2BDB10C9441;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h434FC0000001FFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1042571\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'h43F00001FFF7FFFE;
-    z = 64'h0000000000000000;
-    ans = 64'h43E00001FFF7FFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1043185\n");
-    end
-    x = 64'hC7EFFFC007FFFFFF;
-    y = 64'hC2D0000000000001;
-    z = 64'h40000000007FFFFF;
-    ans = 64'h4ACFFFC008000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1043799\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hFFF0000000000000;
-    z = 64'h8010000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1044413\n");
-    end
-    x = 64'h3FBF09191E8A701F;
-    y = 64'hB17DB7CAEE1A39D7;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1045027\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hC02FFFFFFFC0000F;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1045641\n");
-    end
-    x = 64'h381FFFFFF8000400;
-    y = 64'hBD60081FFFFFFFFF;
-    z = 64'hA9AFFFFEFFFFFFEF;
-    ans = 64'hB590081FFBFDFA00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1046255\n");
-    end
-    x = 64'hC80EEC83DDF4CD6E;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hBFD0000000000001;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1046869\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hC7E0000000100007;
-    z = 64'h31A007FEFFFFFFFF;
-    ans = 64'hC7D0000000100006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1047483\n");
-    end
-    x = 64'h47EFFEFFFFF7FFFF;
-    y = 64'h0000000000000001;
-    z = 64'h3FD007FFFFFFFFFA;
-    ans = 64'h3FD007FFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1048097\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h001003FFFFFFDFFF;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1048711\n");
-    end
-    x = 64'hD34001FFFFEFFFFF;
-    y = 64'h41C2BE85AF0F08B3;
-    z = 64'hB6FFFFFFFDFFBFFF;
-    ans = 64'hD512C0DD7FB22C0D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1049325\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h8000000000000001;
-    ans = 64'h0007FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1049939\n");
-    end
-    x = 64'hB7E0000000000107;
-    y = 64'h3BCFEF765FA7E0D8;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1050553\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h0010000000000001;
-    z = 64'hAE9FFE000001FFFF;
-    ans = 64'hAE9FFE000001FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1051167\n");
-    end
-    x = 64'h3F5FBEFFFFFFFFFF;
-    y = 64'h43EFEFFFFFFFF7FF;
-    z = 64'hBFE0007FFBFFFFFF;
-    ans = 64'h435FAF207FFFF80E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1051781\n");
-    end
-    x = 64'hC887A462950B860F;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1052395\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hC7FFFFFFF003FFFE;
-    z = 64'h400407F04DA9C1E6;
-    ans = 64'hC7EFFFFFF003FFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1053009\n");
-    end
-    x = 64'hBECBC8424E208DC2;
-    y = 64'h3CA0000000000000;
-    z = 64'h43ED932CB1DF65E5;
-    ans = 64'h43ED932CB1DF65E5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1053623\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hBFEFFFFF7FFEFFFE;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1054237\n");
-    end
-    x = 64'h37E176462F866ECA;
-    y = 64'h3FCDFFFFFFFFEFFF;
-    z = 64'hC21A985D8C29A10F;
-    ans = 64'hC21A985D8C29A10F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1054851\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1055465\n");
-    end
-    x = 64'h40CFFFFFFF7DFFFE;
-    y = 64'h41F781EC9ADCFA89;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h42D781EC9A7D7B36;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1056079\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h3FD0000000000000;
-    z = 64'h7FD03FFFDFFFFFFF;
-    ans = 64'h7FD03FFFDFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1056693\n");
-    end
-    x = 64'h43400000100001FE;
-    y = 64'hBE365DEBD46ECD4E;
-    z = 64'hBF4FFF0FFFFFFFFE;
-    ans = 64'hC1865DEBEACEBBDC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1057307\n");
-    end
-    x = 64'h380FFBFFFFF7FFFE;
-    y = 64'h3FD0000000000001;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h37EFFBFFFFF80000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1057921\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h3DFFFFF7FFFFFF7E;
-    z = 64'h7FD0000000000001;
-    ans = 64'h7FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1058535\n");
-    end
-    x = 64'h3F5007FFFFFFFF80;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h3C71FFFFFFFEFFFE;
-    ans = 64'h3F4008000000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1059149\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hB7F00002001FFFFF;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1059763\n");
-    end
-    x = 64'h480FFFFFFFFFF83F;
-    y = 64'hBF2FFFFFFFFFFFFE;
-    z = 64'h802FFFFFFFF801FF;
-    ans = 64'hC74FFFFFFFFFF83D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1060377\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h3FE0000000000001;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1060991\n");
-    end
-    x = 64'h407BFFFFFFDFFFFE;
-    y = 64'hD3CFFFC000000080;
-    z = 64'h3FF0000000000000;
-    ans = 64'hD45BFFC7FFE000AE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1061605\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h43CABC69886420B5;
-    ans = 64'h43CABC69886420B5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1062219\n");
-    end
-    x = 64'h801013FFFFFFFFFF;
-    y = 64'hB28C5CC5F8E8D925;
-    z = 64'hBFD01FFFFFFFFEFE;
-    ans = 64'hBFD01FFFFFFFFEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1062833\n");
-    end
-    x = 64'h4031001FFFFFFFFE;
-    y = 64'h3FF0000000000000;
-    z = 64'h8010000000000000;
-    ans = 64'h4031001FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1063447\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hC000000010400000;
-    z = 64'h48040000000FFFFE;
-    ans = 64'h48040000000FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1064061\n");
-    end
-    x = 64'hC3CFFFFF7FFFF800;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hC34000040000003F;
-    ans = 64'hC3E003FFC0FFFC00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1064675\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hC1C0400002000000;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000008200001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1065289\n");
-    end
-    x = 64'hC800F8701DDBAD16;
-    y = 64'hC7E0000001FFFFF7;
-    z = 64'h3270003FFFDFFFFF;
-    ans = 64'h4FF0F8701FFABB10;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1065903\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h4000000000000000;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1066517\n");
-    end
-    x = 64'hFFE0000000BFFFFF;
-    y = 64'h47EFFEFF7FFFFFFF;
-    z = 64'h3FE0000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1067131\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h4000000000000001;
-    z = 64'h3F5FFFF7FFFC0000;
-    ans = 64'h3FF007FFFDFFFF00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1067745\n");
-    end
-    x = 64'h4035C9DBE1FE4CF2;
-    y = 64'h41EFFFF7FFFFFFFE;
-    z = 64'h3F8FFFFDFFFDFFFF;
-    ans = 64'h4235C9D66F875871;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1068359\n");
-    end
-    x = 64'h802000007FFFFFBF;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h8000000000000001;
-    ans = 64'h804000007FFFFFBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1068973\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h401B82AFA2781976;
-    z = 64'h43C203FFFFFFFFFF;
-    ans = 64'h43C203FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1069587\n");
-    end
-    x = 64'hC1CFFFFFFFF00001;
-    y = 64'h4010000000000001;
-    z = 64'h1C2B3ED2326B0A9D;
-    ans = 64'hC1EFFFFFFFF00003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1070201\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hC1EFFBFFFFFFFFF7;
-    z = 64'hC010000000000001;
-    ans = 64'hC1DFFC0000FFFFF5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1070815\n");
-    end
-    x = 64'h4341FFFFFFFFFF00;
-    y = 64'h41B0000102000000;
-    z = 64'h3FA2FCF93281DA50;
-    ans = 64'h45020001223FFF00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1071429\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1072043\n");
-    end
-    x = 64'hB7E0000FFFEFFFFF;
-    y = 64'hC0075D6CD888AC6C;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1072657\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h4340000000000000;
-    z = 64'h381B3756C7E0CEA2;
-    ans = 64'h432FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1073271\n");
-    end
-    x = 64'hC7FFFF000001FFFE;
-    y = 64'hBFF0000100001FFF;
-    z = 64'h43C00000800FFFFF;
-    ans = 64'h47FFFF01FFF23FFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1073885\n");
-    end
-    x = 64'h3FB00000001FBFFF;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1074499\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h80100000103FFFFF;
-    z = 64'h4030000010000003;
-    ans = 64'h4030000010000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1075113\n");
-    end
-    x = 64'h20200003FFFFFBFF;
-    y = 64'h7FE0000000000000;
-    z = 64'hC50CBDCA372F5092;
-    ans = 64'h60100003FFFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1075727\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hB7EF8000007FFFFF;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1076341\n");
-    end
-    x = 64'h800E082148C2033E;
-    y = 64'h403604647E01C31D;
-    z = 64'h43E55C3E9937D71C;
-    ans = 64'h43E55C3E9937D71C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1076955\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h7FDFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1077569\n");
-    end
-    x = 64'h43EEFF0000000000;
-    y = 64'h7FFDE1631284A2C5;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h7FFDE1631284A2C5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1078183\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hBFD000001000001F;
-    ans = 64'h7FDFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1078797\n");
-    end
-    x = 64'h400A5BB8D30DC2EF;
-    y = 64'h4110007FFFFFE000;
-    z = 64'hC00FFFFE0FFFFFFF;
-    ans = 64'h412A5C83B0D4A2A6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1079411\n");
-    end
-    x = 64'h402FFF7FFF7FFFFF;
-    y = 64'h7FF0000000000001;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1080025\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hC1C043520BF4D23A;
-    z = 64'h31500000000001F7;
-    ans = 64'hC1B043520BF4D239;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1080639\n");
-    end
-    x = 64'h403FFFFFE0200000;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h477FFFFFDFFFBFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1081253\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hC1EFFFFFFBFFFF7F;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hC1DFFFFFFC7FFF7D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1081867\n");
-    end
-    x = 64'hC1EE9E66872FC38D;
-    y = 64'h36C98C27589707B2;
-    z = 64'hD498E3DB9F1B5795;
-    ans = 64'hD498E3DB9F1B5795;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1082481\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h8000000000000001;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1083095\n");
-    end
-    x = 64'hC037A9075979CBC4;
-    y = 64'h40518D2E789419D0;
-    z = 64'h3CA0000000000000;
-    ans = 64'hC099F45E1819C3E1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1083709\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hBF8000002000000F;
-    ans = 64'hBF8000002000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1084323\n");
-    end
-    x = 64'hBFCFF0000003FFFF;
-    y = 64'hFFDFF7FFFFFFF000;
-    z = 64'h3D0FE000001FFFFF;
-    ans = 64'h7FBFE8040003EF07;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1084937\n");
-    end
-    x = 64'hBFC8A912FAE0FC93;
-    y = 64'h8010000000000000;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1085551\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h3FEFFFBFF0000000;
-    z = 64'h41C2406AD1F3DEA0;
-    ans = 64'h41C2406AD233DE20;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1086165\n");
-    end
-    x = 64'hB7F4FFFFFFFFFFFE;
-    y = 64'h8010000000000001;
-    z = 64'hC1C00000000400FF;
-    ans = 64'hC1C00000000400FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1086779\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h40500000001FBFFE;
-    z = 64'hBFF0000000000000;
-    ans = 64'h403F0000003F7FFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1087393\n");
-    end
-    x = 64'hBFB39DB3C745AB05;
-    y = 64'hC28FFFFFFFFFDFE0;
-    z = 64'hBDEFFFFFFC000800;
-    ans = 64'h42539DB3C7459754;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1088007\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hBCA0000000000000;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1088621\n");
-    end
-    x = 64'hABCB70E42BF56E97;
-    y = 64'h43CFFF00000001FF;
-    z = 64'h0010000000000001;
-    ans = 64'hAFAB7008A4D410A2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1089235\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hBCA0000000000001;
-    z = 64'h3FE0000013FFFFFF;
-    ans = 64'h3FE0000013FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1089849\n");
-    end
-    x = 64'hC4D03FFFFFFFFFFF;
-    y = 64'hE2387F5A30B75DCE;
-    z = 64'hC030FFFFFFFFFFDF;
-    ans = 64'h6718E157997A3B44;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1090463\n");
-    end
-    x = 64'hC1CFFFFFF7FFFFF7;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1091077\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hC7FFFFFFC000007F;
-    z = 64'hBFF4FFFFFFFFFFFF;
-    ans = 64'hC7EFFFFFC000007D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1091691\n");
-    end
-    x = 64'h37500007FFFEFFFF;
-    y = 64'hBFD0000000000000;
-    z = 64'h000FFFFFF800007F;
-    ans = 64'hB7300007FFFEFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1092305\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h5E30FFF000000000;
-    z = 64'hBFE0000000000001;
-    ans = 64'h5E20FFEFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1092919\n");
-    end
-    x = 64'hC9E919F45AC84E5F;
-    y = 64'hBF00004000002000;
-    z = 64'h3FAFFFC100000000;
-    ans = 64'h48F91A58C299EBB4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1093533\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FE8000000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1094147\n");
-    end
-    x = 64'h47F0000000000DFF;
-    y = 64'h381FFC000000001E;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h401FFC0000001C19;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1094761\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hBFE0000000000000;
-    z = 64'hC4DFFFFFDFBFFFFE;
-    ans = 64'hC4DFFFFFDFBFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1095375\n");
-    end
-    x = 64'h3FD3AD346C33E68E;
-    y = 64'hC1051C2D00B3BF05;
-    z = 64'h3FDFFFEFFFFF7FFF;
-    ans = 64'hC0E9F5EB41C9F664;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1095989\n");
-    end
-    x = 64'hC3F27A392E74EC3D;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h43F27A392E74EC3C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1096603\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h381FFFFFFFFF8100;
-    z = 64'hC01FFFFFFFEFC000;
-    ans = 64'hC01FFFFFFFEFC000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1097217\n");
-    end
-    x = 64'hC09FFEFFFFFFFFBF;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hC0145E9928594298;
-    ans = 64'h409FEAA166D7A67A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1097831\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h43DFF00000000003;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'h43CFF00000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1098445\n");
-    end
-    x = 64'hBFFFFFE000000003;
-    y = 64'h3F0C000001FFFFFF;
-    z = 64'h5B60000000000100;
-    ans = 64'h5B60000000000100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1099059\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1099673\n");
-    end
-    x = 64'hAC0F800000000001;
-    y = 64'hFFFFFFFFFDFFFFFB;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1100287\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h41FFFFFFFEFFF7FE;
-    ans = 64'h41FFFFFFFEEFF7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1100901\n");
-    end
-    x = 64'hC4D21A55752A67B8;
-    y = 64'h3DABFFEFFFFFFFFF;
-    z = 64'hBE0FFFE0000FFFFF;
-    ans = 64'hC28FAE0372B4C056;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1101515\n");
-    end
-    x = 64'hBFD0000000000EFF;
-    y = 64'hC000000000000001;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h40120000000001DF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1102129\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hFFF4E88B301CCC49;
-    z = 64'h41CFFFFFEFFFEFFF;
-    ans = 64'hFFFCE88B301CCC49;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1102743\n");
-    end
-    x = 64'hC3DFFFF0000FFFFE;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h3800007FFFFFFFC0;
-    ans = 64'h43FFFFF0000FFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1103357\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hC03FFFFF7FDFFFFE;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hC02FFFFF7FDFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1103971\n");
-    end
-    x = 64'hC7FFFFFFFB7FFFFF;
-    y = 64'h37EFFFFFFFDFFBFF;
-    z = 64'hC34000003FFFFFFC;
-    ans = 64'hC34000003FFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1104585\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hC010000000000001;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'hBFF8000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1105199\n");
-    end
-    x = 64'h40F01FFFFFFFFFF6;
-    y = 64'hB7FEFFFF7FFFFFFE;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1105813\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h400E000000000000;
-    ans = 64'hBFCFFFFFFFFFFFD0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1106427\n");
-    end
-    x = 64'h002FFFFFFF700000;
-    y = 64'hB7EFFFFFFFFFDFBF;
-    z = 64'hB7FB7132663A42B2;
-    ans = 64'hB7FB7132663A42B2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1107041\n");
-    end
-    x = 64'hBFD0008000003FFE;
-    y = 64'hC340000000000000;
-    z = 64'h4000000000000000;
-    ans = 64'h4320008000004002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1107655\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h3E1FFFFFFEFFF000;
-    z = 64'h3FEFDFFFFFFFFFFF;
-    ans = 64'h3FEFE000007FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1108269\n");
-    end
-    x = 64'hEAF000000000FFDF;
-    y = 64'hC340000000000001;
-    z = 64'hBF4000000023FFFE;
-    ans = 64'h6E4000000000FFE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1108883\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'h41F00007FFF7FFFE;
-    z = 64'hBCA0000000000000;
-    ans = 64'h41E00007FFF7FFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1109497\n");
-    end
-    x = 64'h802FFFFFFF7FFC00;
-    y = 64'hBA003FFFFE000000;
-    z = 64'h41F5E9BB04770872;
-    ans = 64'h41F5E9BB04770872;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1110111\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hFFE0000000000000;
-    z = 64'h3FD0000000000000;
-    ans = 64'hFFCFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1110725\n");
-    end
-    x = 64'hC3EFFFFFDFC00000;
-    y = 64'hC0388527EF25A62F;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1111339\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hFFE0000000000001;
-    z = 64'hC0507FFFFFFFF800;
-    ans = 64'hFFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1111953\n");
-    end
-    x = 64'h3F2000100FFFFFFF;
-    y = 64'hB80FFFFFFFF80100;
-    z = 64'hCBC0000010010000;
-    ans = 64'hCBC0000010010000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1112567\n");
-    end
-    x = 64'h2FC3FEE42A17A068;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h3FF0000000000001;
-    ans = 64'hEFC3FEE42A17A067;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1113181\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hAC886013D8702B8D;
-    z = 64'h7FF0001FFFE00000;
-    ans = 64'h7FF8001FFFE00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1113795\n");
-    end
-    x = 64'hC3FFFFFFFFFFFFFF;
-    y = 64'hFFF0000000000000;
-    z = 64'h54BEFFFF7FFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1114409\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hC7F1FFFF80000000;
-    z = 64'h8010000000000001;
-    ans = 64'hC7E1FFFF7FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1115023\n");
-    end
-    x = 64'h40200003FFFFDFFF;
-    y = 64'hB1407FFFFFEFFFFF;
-    z = 64'hC02008000000003F;
-    ans = 64'hC02008000000003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1115637\n");
-    end
-    x = 64'h3FDFFFFFFFFFFFFE;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h3CA0000000000001;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1116251\n");
-    end
-    x = 64'hBE62C38E424FE361;
-    y = 64'h412FFFBFFFFFFFBE;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1116865\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h0000000000000000;
-    z = 64'h000F7FFFBFFFFFFF;
-    ans = 64'h000F7FFFBFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1117479\n");
-    end
-    x = 64'hC80FFFFF7FFFFFDF;
-    y = 64'h227C56AAB6DA3602;
-    z = 64'h94B4858BCE164D6E;
-    ans = 64'hAA9C56AA457F8B09;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1118093\n");
-    end
-    x = 64'h43D03FFFFEFFFFFE;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1118707\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hBFEFFFFFF8020000;
-    z = 64'h41EAECD3F27183B9;
-    ans = 64'h41EAECD3F26183B9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1119321\n");
-    end
-    x = 64'h46CFFFFFF7FFFFFF;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h55FFFFFFFFFFF002;
-    ans = 64'h55FFFFFFFFFFF002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1119935\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hBFBFFE07FFFFFFFF;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'hBFAFFE07FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1120549\n");
-    end
-    x = 64'h418FFFFFFFFC0100;
-    y = 64'h41C001FFFFDFFFFF;
-    z = 64'h7DB000800007FFFE;
-    ans = 64'h7DB000800007FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1121163\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h0027FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1121777\n");
-    end
-    x = 64'hC7FE000400000000;
-    y = 64'h3FF20000000007FF;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC800E0024000077F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1122391\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hC1F3FF7FFFFFFFFF;
-    ans = 64'hC1F3FF7FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1123005\n");
-    end
-    x = 64'hC0300FFFFFFFFFFD;
-    y = 64'h3FB03FFFFFFF7FFE;
-    z = 64'hFFD0001FFFFFFF7E;
-    ans = 64'hFFD0001FFFFFFF7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1123619\n");
-    end
-    x = 64'h40EFFFEFFFFFFDFF;
-    y = 64'h3CA0000000000001;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FE000000000FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1124233\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h415FFFF004000000;
-    z = 64'h41FEFFFFFFFFEFFF;
-    ans = 64'h41FF03FFFE006FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1124847\n");
-    end
-    x = 64'h6AFFFFFFFFFDDFFF;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h3FCFFFC01FFFFFFF;
-    ans = 64'h67BFFFFFFFFDDFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1125461\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC06000000000006F;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1126075\n");
-    end
-    x = 64'hBF4F800000000006;
-    y = 64'hBF800003FFBFFFFF;
-    z = 64'h550E46264996A342;
-    ans = 64'h550E46264996A342;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1126689\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h3FD0000000000001;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h3FC0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1127303\n");
-    end
-    x = 64'hBCAFFF7FBFFFFFFF;
-    y = 64'hBF8FFFFFFFFFE7FF;
-    z = 64'hC010000000000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1127917\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h3CAEFFFFF7FFFFFF;
-    ans = 64'h3FD0000000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1128531\n");
-    end
-    x = 64'hC0F2269EA37979B7;
-    y = 64'hC3E5044465ED15FE;
-    z = 64'h99006FFFFFFFFFFE;
-    ans = 64'h44E7D78775FB434B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1129145\n");
-    end
-    x = 64'hBDAFFFFFBFFFFFC0;
-    y = 64'h3FE0000000000000;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FCFFFFFFFFC0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1129759\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC02FBFFFFFFFFC00;
-    z = 64'hBF4FFFFFFC080000;
-    ans = 64'hC01FC0FFFFFFDC40;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1130373\n");
-    end
-    x = 64'h43C4B497E002A189;
-    y = 64'h3FE0000000000001;
-    z = 64'h3FB00000013FFFFF;
-    ans = 64'h43B4B497E002A18A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1130987\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hBA8FDFFFFFFFF7FF;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1131601\n");
-    end
-    x = 64'hC05007F800000000;
-    y = 64'h7FD0010000000007;
-    z = 64'h3DCE087CDC3EE03D;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1132215\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h3FF0000000000000;
-    z = 64'h0000000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1132829\n");
-    end
-    x = 64'h40100000000040FF;
-    y = 64'h40382A63E3DB7F32;
-    z = 64'hC000000000000001;
-    ans = 64'h4057AA63E3DBE15D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1133443\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h3FF0000000000001;
-    z = 64'h403BFF7FFFFFFFFE;
-    ans = 64'h403C7F7FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1134057\n");
-    end
-    x = 64'hCCEFFFFFDFF7FFFF;
-    y = 64'h1B3C000000003FFE;
-    z = 64'hC3E000007FFBFFFE;
-    ans = 64'hC3E000007FFBFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1134671\n");
-    end
-    x = 64'h4420003FFFFF8000;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h3CA0000000000001;
-    ans = 64'h4430003FFFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1135285\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h380FFFFFFD7FFFFE;
-    z = 64'hBFEFBFFFFFFFFFF0;
-    ans = 64'hBFEFBFFFFFFFFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1135899\n");
-    end
-    x = 64'h41EC9BDA337E16AB;
-    y = 64'h4000000000000000;
-    z = 64'hB50FFFFFFFFEFFEE;
-    ans = 64'h41FC9BDA337E16AB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1136513\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hA6741A0E20872621;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1137127\n");
-    end
-    x = 64'h5FA00000010000FF;
-    y = 64'hC000000003FFFDFE;
-    z = 64'h3CC7741A54494340;
-    ans = 64'hDFB0000004FFFEFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1137741\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1138355\n");
-    end
-    x = 64'hBFE7198953B924E4;
-    y = 64'h19E201FFFFFFFFFE;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1138969\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h4010000000000000;
-    z = 64'h3FDFBFFFFFFEFFFF;
-    ans = 64'h4003F7FFFFFFE000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1139583\n");
-    end
-    x = 64'h7FE00000003FFFEE;
-    y = 64'hC6A01000000007FE;
-    z = 64'h386001000FFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1140197\n");
-    end
-    x = 64'h41CC0C7A32611D71;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h41FC0C7A32611D70;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1140811\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC1FFFFFF000001FF;
-    z = 64'h800FFFFFFFFFFDDE;
-    ans = 64'hC1EFFFFF000001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1141425\n");
-    end
-    x = 64'h402FFFFFFF7F7FFE;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h801FFFEFFFFFFE00;
-    ans = 64'h405FFFFFFF7F7FFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1142039\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hE0600007FFFFFC00;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'hE0500007FFFFFC00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1142653\n");
-    end
-    x = 64'h42CBB2BFC8A9AB72;
-    y = 64'hFFEFFFFFF800001E;
-    z = 64'hC3D1FFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1143267\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h4340000000000001;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1143881\n");
-    end
-    x = 64'h800A63B087D63021;
-    y = 64'h42DFFFFFFDFFFC00;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1144495\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h4A2FFFFFFFDFFFFF;
-    ans = 64'h4A2FFFFFFFDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1145109\n");
-    end
-    x = 64'h42EA28F2F54C20DD;
-    y = 64'hBFDFFFEFF0000000;
-    z = 64'h3F6FFFFFFE1FFFFF;
-    ans = 64'hC2DA28E5D3BE2CBC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1145723\n");
-    end
-    x = 64'h401FFFFBFFFFFF7F;
-    y = 64'h7FE0000000000001;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1146337\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h40FAA9DBBA56F555;
-    z = 64'h45100000400003FF;
-    ans = 64'h45100000400003FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1146951\n");
-    end
-    x = 64'h3A3FFF8000007FFF;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h400FFBFFFFFFFFBF;
-    ans = 64'h7A3FFF8000007FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1147565\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC7E0004003FFFFFE;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'hC7D0004003FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1148179\n");
-    end
-    x = 64'h43F027459B92631B;
-    y = 64'hC060000200000003;
-    z = 64'h43E0000012000000;
-    ans = 64'hC4601747A0691690;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1148793\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h7FF0000000000000;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1149407\n");
-    end
-    x = 64'hC1DFE00000000001;
-    y = 64'h37FFFFFFFBFFBFFE;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1150021\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h37EFFC00007FFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1150635\n");
-    end
-    x = 64'h418FC8D90993BDBB;
-    y = 64'h46AFFFDFFFFEFFFF;
-    z = 64'h404B2AA5588E3698;
-    ans = 64'h484FC8B940B9B5DF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1151249\n");
-    end
-    x = 64'h3F35B1AD19CCBB88;
-    y = 64'h8000000000000000;
-    z = 64'h0000000000000000;
-    ans = 64'h0000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1151863\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h41CFFFFEFFFFC000;
-    z = 64'hC7E00000008FFFFF;
-    ans = 64'hC7E00000008FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1152477\n");
-    end
-    x = 64'h3FCFF0000000007F;
-    y = 64'h8000000000000001;
-    z = 64'h4024D806BCE3C412;
-    ans = 64'h4024D806BCE3C412;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1153091\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC310000043FFFFFE;
-    z = 64'h4010000000000000;
-    ans = 64'hC300000043FFFFDE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1153705\n");
-    end
-    x = 64'h22973342C2D94245;
-    y = 64'hBC5000007FFFFF00;
-    z = 64'h3FD000FFFFFFFF7E;
-    ans = 64'h3FD000FFFFFFFF7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1154319\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1154933\n");
-    end
-    x = 64'hBFB60F9E9B37FF4D;
-    y = 64'hBE9007FFFFFFFBFF;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFCFFFFFD3CAB32D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1155547\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h8010000000000001;
-    z = 64'h7FF0000000000023;
-    ans = 64'h7FF8000000000023;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1156161\n");
-    end
-    x = 64'hBF600000000001FF;
-    y = 64'h401E1107EFF9A8DC;
-    z = 64'hCFC0FE0000000000;
-    ans = 64'hCFC0FE0000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1156775\n");
-    end
-    x = 64'hC383A01B0A54CF13;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1157389\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC3E89E6D0A424544;
-    z = 64'h000053D77B90F71D;
-    ans = 64'hC3D89E6D0A424544;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1158003\n");
-    end
-    x = 64'hC1FFFFFFDF800000;
-    y = 64'hBCA0000000000000;
-    z = 64'hBDF0200000003FFE;
-    ans = 64'h3EAFFDFBDF7FFFF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1158617\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC3C0000001DFFFFF;
-    z = 64'h4000000000000001;
-    ans = 64'hC3B0000001DFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1159231\n");
-    end
-    x = 64'hC34FFFFFFFFF87FE;
-    y = 64'h41EFFFFFFFF003FF;
-    z = 64'h105000004000000F;
-    ans = 64'hC54FFFFFFFEF8BFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1159845\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1160459\n");
-    end
-    x = 64'hC3E00000005FFFFF;
-    y = 64'h8C5001FFFFFFBFFF;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1161073\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hBFD0000000000000;
-    z = 64'hC7FFFFFBFDFFFFFF;
-    ans = 64'hC7FFFFFBFDFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1161687\n");
-    end
-    x = 64'h490723EB06262E31;
-    y = 64'hFD18000000FFFFFF;
-    z = 64'h3C1000004000FFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1162301\n");
-    end
-    x = 64'hB7EFFFFFFBFFF800;
-    y = 64'hBFD0000000000001;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1162915\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC7F02007FFFFFFFE;
-    z = 64'hBB5605238E05DFBA;
-    ans = 64'hC7E02007FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1163529\n");
-    end
-    x = 64'h7FFFFFFFF7FFFFFA;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h318E000004000000;
-    ans = 64'h7FFFFFFFF7FFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1164143\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC0353E5BC7EF131D;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'hC0213E5BC7EF131D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1164757\n");
-    end
-    x = 64'hC3400040000003FE;
-    y = 64'hC03FE00000100000;
-    z = 64'h3FF494F28DCAC0D3;
-    ans = 64'h438FE07F80100834;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1165371\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hBFE0000000000001;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC011000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1165985\n");
-    end
-    x = 64'hC3EFFFFFFFE003FF;
-    y = 64'hC21FBFFFFFDFFFFE;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h461FBFFFFFC043F5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1166599\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h434FFFFF1FFFFFFF;
-    ans = 64'h434FFFFF1FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1167213\n");
-    end
-    x = 64'h3E10000207FFFFFF;
-    y = 64'hC5C185538585F023;
-    z = 64'h7FD0000FFFFFBFFF;
-    ans = 64'h7FD0000FFFFFBFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1167827\n");
-    end
-    x = 64'h800FFFFFFDFFFFFF;
-    y = 64'hBFF0000000000000;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1168441\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC1CFFFFFFFF7FFDF;
-    z = 64'hC01000000003FFFB;
-    ans = 64'hC1C0000001FBFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1169055\n");
-    end
-    x = 64'h9D9000000000407F;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h3FC000800000FFFF;
-    ans = 64'h3FC000800000FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1169669\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h4163FFFFFFFFFFBE;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h415400003FFFFFBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1170283\n");
-    end
-    x = 64'hC03FFFFFFFFF7EFE;
-    y = 64'h381EFFFFFFFFFF7E;
-    z = 64'h3FE800001FFFFFFF;
-    ans = 64'h3FE800001FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1170897\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC000000000000000;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hC007FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1171511\n");
-    end
-    x = 64'h3FFB431B34B7CE0C;
-    y = 64'hC7F000000003FFFC;
-    z = 64'h8010000000000000;
-    ans = 64'hC7FB431B34BE9ECC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1172125\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hC1F25D65F88033E0;
-    ans = 64'hC1F25D65F8A033E0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1172739\n");
-    end
-    x = 64'h800FEEFFFFFFFFFF;
-    y = 64'h7FD1FFFFFFFFFFF6;
-    z = 64'hBF70000000003FBE;
-    ans = 64'hBFF1FCE000000035;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1173353\n");
-    end
-    x = 64'h09C0200002000000;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1173967\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h4010000000801FFF;
-    z = 64'hBFAFFFC800000000;
-    ans = 64'h3FFF0001C1003FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1174581\n");
-    end
-    x = 64'hC1C581FBC774F374;
-    y = 64'hC010000000000001;
-    z = 64'hC00FFFF3FFFFFFFE;
-    ans = 64'h41E581FBC6F4F3A5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1175195\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h3BFFFFFFFFFFF6FF;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1175809\n");
-    end
-    x = 64'h37FBD52CF116FCB7;
-    y = 64'h3FC8800000000000;
-    z = 64'h43F0FFFFFFFFFFFE;
-    ans = 64'h43F0FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1176423\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hBFF0000000000000;
-    ans = 64'hC013FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1177037\n");
-    end
-    x = 64'h400FFFFFEFFFFFFB;
-    y = 64'hAAF0C734E2A389B1;
-    z = 64'h8000000000000001;
-    ans = 64'hAB10C734DA3FEF3D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1177651\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hC340000000000001;
-    z = 64'h5C37AF0E6B6739FF;
-    ans = 64'h5C37AF0E6B6739FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1178265\n");
-    end
-    x = 64'hB7EFFFF80000000F;
-    y = 64'hDD90000020000007;
-    z = 64'hB80B36A0270E1A29;
-    ans = 64'h558FFFF83FFFF01D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1178879\n");
-    end
-    x = 64'hBE97FFFFFFFFFFFC;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hC010000000000001;
-    ans = 64'h41F7FFFFFFBFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1179493\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h4800001FFFFFFFFE;
-    z = 64'h72E0000010000000;
-    ans = 64'h72E0000010000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1180107\n");
-    end
-    x = 64'hC05000403FFFFFFF;
-    y = 64'hFFE0000000000000;
-    z = 64'h397EBF9F5C9C83E9;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1180721\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h0B9CBD5808FDB0FE;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1181335\n");
-    end
-    x = 64'hBFF9104A39BDD7BB;
-    y = 64'h3FFEFFFFEFFFFFFF;
-    z = 64'h4020000FFFFFFFF0;
-    ans = 64'h4013DC3C124C1DF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1181949\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hBFE0000000000001;
-    ans = 64'hFFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1182563\n");
-    end
-    x = 64'hC1901FFBFFFFFFFE;
-    y = 64'h3CF010001FFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1183177\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'hFFF0000000000000;
-    z = 64'hBFCCA72E89F506ED;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1183791\n");
-    end
-    x = 64'h000020000000001E;
-    y = 64'hD9AFFFFFFFEFFFDE;
-    z = 64'h3FB1000000008000;
-    ans = 64'h3FB1000000008000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1184405\n");
-    end
-    x = 64'h41F89968EBD9BC5C;
-    y = 64'hFFF0000000000001;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1185019\n");
-    end
-    x = 64'h3FE0000000000000;
-    y = 64'h43D1CCF3DD115F1B;
-    z = 64'h4000100003FFFFFF;
-    ans = 64'h43C1CCF3DD115F1B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1185633\n");
-    end
-    x = 64'h801DFFFFFFFF7FFE;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h002E0001FFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1186247\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hB81FFFFFF7FE0000;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1186861\n");
-    end
-    x = 64'hBFD0000000000100;
-    y = 64'h43400000000007FE;
-    z = 64'hBF80200007FFFFFF;
-    ans = 64'hC3200000000008FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1187475\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h0000000000000001;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1188089\n");
-    end
-    x = 64'hC1E7433321AAB73A;
-    y = 64'hC20007FFFFFFFFE0;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1188703\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h3CAFF0000000003F;
-    ans = 64'h3CAFF0000000003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1189317\n");
-    end
-    x = 64'h43D00004000003FE;
-    y = 64'h8D00800000000000;
-    z = 64'h775FFFFFF7FFFF7F;
-    ans = 64'h775FFFFFF7FFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1189931\n");
-    end
-    x = 64'h400FFFFFFFFC0001;
-    y = 64'h0010000000000000;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1190545\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h528FFFDFF7FFFFFF;
-    z = 64'h41C0020080000000;
-    ans = 64'h527FFFDFF8000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1191159\n");
-    end
-    x = 64'hD3CFEFFFBFFFFFFF;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hDC7000000000401F;
-    ans = 64'hDC7000000000401F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1191773\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h2A9C69744FCB1FC1;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h2A8C69744FCB1FC3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1192387\n");
-    end
-    x = 64'hC15000000000011F;
-    y = 64'hC01FF7FFFFFFDFFF;
-    z = 64'hC67FFFFFFFFFFFC8;
-    ans = 64'hC67FFFFFFFFFFFC8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1193001\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h3CA0000000000000;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBCA7FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1193615\n");
-    end
-    x = 64'hBFDAFBBC119D048E;
-    y = 64'h41DFFFFC00200000;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1194229\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hC1C0000008000010;
-    ans = 64'hC1C0000008000010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1194843\n");
-    end
-    x = 64'h3F3FFFFFFFC00001;
-    y = 64'h832FFFFFFFFFF400;
-    z = 64'hB8100001FFFFC000;
-    ans = 64'hB8100001FFFFC000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1195457\n");
-    end
-    x = 64'h197FFEFFFFFFEFFF;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1196071\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h3FCF000000400000;
-    z = 64'h50E00000000000FE;
-    ans = 64'h50E00000000000FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1196685\n");
-    end
-    x = 64'hE7BFFFFC0000007E;
-    y = 64'h3FD0000000000001;
-    z = 64'hFFFE22D338585265;
-    ans = 64'hFFFE22D338585265;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1197299\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h001FFFE000001FFF;
-    z = 64'h0010000000000000;
-    ans = 64'h001FFFF000001000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1197913\n");
-    end
-    x = 64'hBFD40000000003FF;
-    y = 64'hC5B1000001FFFFFF;
-    z = 64'h4050000000FFFDFF;
-    ans = 64'h459540000280043E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1198527\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hBCA0000000000000;
-    ans = 64'h3FCFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1199141\n");
-    end
-    x = 64'h410FE00000000001;
-    y = 64'hB800000047FFFFFF;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1199755\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h3FE0000000000001;
-    z = 64'h40780CC8FBC669E4;
-    ans = 64'h407810C8FBC669E4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1200369\n");
-    end
-    x = 64'h403A681B52736AB4;
-    y = 64'hB547FFFFFFFFF7FF;
-    z = 64'hBFE0000007FFFFBF;
-    ans = 64'hBFE0000007FFFFBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1200983\n");
-    end
-    x = 64'hFFEFFFFFFFFFF800;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'hBFE0000000000001;
-    ans = 64'hFFEFFFFFFFFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1201597\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h480FFFFFEFFFFFF7;
-    z = 64'hC7F0000000023FFF;
-    ans = 64'h47EFFFFFDFFB7FF4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1202211\n");
-    end
-    x = 64'h802FFFFDFBFFFFFF;
-    y = 64'h3FF0000000000000;
-    z = 64'hBFFFBFFFFFFBFFFF;
-    ans = 64'hBFFFBFFFFFFBFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1202825\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h415F94D2F6C29D24;
-    z = 64'h0000000000000001;
-    ans = 64'h414F94D2F6C29D26;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1203439\n");
-    end
-    x = 64'h3FCB3C1786B1DCDD;
-    y = 64'h40001000000001FF;
-    z = 64'hC01000000203FFFE;
-    ans = 64'hC00C95159040EDB8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1204053\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h8010000000000001;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1204667\n");
-    end
-    x = 64'hC1F1FFFFFF000000;
-    y = 64'h3F50040002000000;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'hC152047E013FC000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1205281\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h4000000000000000;
-    z = 64'h43FFFFFFFFF01FFE;
-    ans = 64'h43FFFFFFFFF01FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1205895\n");
-    end
-    x = 64'hC030000400100000;
-    y = 64'hC340001FFFFFFFFE;
-    z = 64'hFFE000003FDFFFFF;
-    ans = 64'hFFE000003FDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1206509\n");
-    end
-    x = 64'hB80000000000081F;
-    y = 64'h4000000000000001;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1207123\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hB7E0000000001100;
-    z = 64'h3FD04000000007FF;
-    ans = 64'h3FD04000000007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1207737\n");
-    end
-    x = 64'hC3F0803FFFFFFFFF;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h863FFFFFFEFFFFC0;
-    ans = 64'hC410803FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1208351\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h40100000041FFFFE;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1208965\n");
-    end
-    x = 64'h3FCFAA45B9D49991;
-    y = 64'h306FDFFFFFFEFFFF;
-    z = 64'h9C3000000000FFFB;
-    ans = 64'h304F8A9B7419C7A4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1209579\n");
+    	$fwrite(fp,"1033667\n");
     end
-    x = 64'h3FE0000000000001;
-    y = 64'h4010000000000001;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h4000000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC0A000000002001E;
+    ReadData3E = 64'hFFFC4C6E938BCF63;
+    ans = 64'hFFFC4C6E938BCF63;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1210193\n");
+    	$fwrite(fp,"1033973\n");
     end
-    x = 64'hBEFCAD5EA5228D2B;
-    y = 64'hC3EFFFFFFFFFFFBC;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h42FCAD5EA5228D2E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3EF4000000001FFF;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'hBFD0000000000000;
+    ans = 64'hBFD000A000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1210807\n");
+    	$fwrite(fp,"1034279\n");
     end
-    x = 64'h3FE0000000000001;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h47F000000040FFFF;
-    ans = 64'h47F000000040FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h001FFF01FFFFFFFF;
+    ReadData2E = 64'h7FF020000001FFFF;
+    ReadData3E = 64'hC00FFFFFFF002000;
+    ans = 64'h7FF820000001FFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1211421\n");
+    	$fwrite(fp,"1034585\n");
     end
-    x = 64'h434005FFFFFFFFFE;
-    y = 64'h3FBFFFFFCFFFFFFF;
-    z = 64'h3F5FFFFFFFFFFFCF;
-    ans = 64'h431005FFE7F6FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h41FFFF7FFFFFFFFD;
+    ans = 64'h41FFFF7FFFDFFFFD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1212035\n");
+    	$fwrite(fp,"1034891\n");
     end
-    x = 64'hC01FFFFF7FFFFFEF;
-    y = 64'h4340000000000000;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hC36FFFFF7FFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h40600000002007FF;
+    ReadData2E = 64'h404FFFFFFFFEFFBF;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'h40BFFC00003F0FBD;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1212649\n");
+    	$fwrite(fp,"1035197\n");
     end
-    x = 64'h3FE0000000000001;
-    y = 64'h43FFFFFC00100000;
-    z = 64'hC80A2913FEE53A41;
-    ans = 64'hC80A2913FEE53A41;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFE;
+    ans = 64'hBFF7FFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1213263\n");
+    	$fwrite(fp,"1035503\n");
     end
-    x = 64'h3808F00FB1D7348D;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h43D56A1EBF8784C2;
-    ans = 64'h43D56A1EBF8784C2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h7FEFFFFFFFFFF01F;
+    ReadData2E = 64'hBFC00000003FFFBF;
+    ReadData3E = 64'h41684E7E00A71AE6;
+    ans = 64'hFFC00000003FF7CE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1213877\n");
+    	$fwrite(fp,"1035809\n");
     end
-    x = 64'h3FE0000000000001;
-    y = 64'h3FF00000FBFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFE;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hCDC6B77D8EB7FA00;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFE;
     ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1214491\n");
+    	$fwrite(fp,"1036115\n");
     end
-    x = 64'h53AFCC613E2DB334;
-    y = 64'hBFDFE00000001FFF;
-    z = 64'h47F4000200000000;
-    ans = 64'hD39FAC94DCEFA54C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBAB0000FFFFFFFEF;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'h939FF7FFFFFE0000;
+    ans = 64'h3AD0000FFFFFFFEF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1215105\n");
+    	$fwrite(fp,"1036421\n");
     end
-    x = 64'h3FE0000000000001;
-    y = 64'h7FE0000000000000;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFF0001FFFFF8000;
+    ReadData3E = 64'h402FFF7000000000;
+    ans = 64'hFFF8001FFFFF8000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1215719\n");
+    	$fwrite(fp,"1036727\n");
     end
-    x = 64'h3D4BE86A57F38F49;
-    y = 64'hB7E71747894EDFF3;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1216333\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h3FEF01FFFFFFFFFE;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1216947\n");
-    end
-    x = 64'hC2E000007FFFFFFE;
-    y = 64'hBFB0000800020000;
-    z = 64'hC7FE0000001FFFFE;
-    ans = 64'hC7FE0000001FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1217561\n");
-    end
-    x = 64'h4A37FFFFBFFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hBCA0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1218175\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h43FF1370D02201AA;
-    z = 64'hC013FFFFFFFFFFFC;
-    ans = 64'h43EF1370D02201AC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1218789\n");
-    end
-    x = 64'hBF6D59563B67BDFB;
-    y = 64'h7FF0000000000001;
-    z = 64'h401FF8000000FFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1219403\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h41F000FFFFFEFFFE;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1220017\n");
-    end
-    x = 64'hBE422263AC5FA438;
-    y = 64'hC0E5FEBF1FFB3F2D;
-    z = 64'h4806E95AD3698BE1;
-    ans = 64'h4806E95AD3698BE1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1220631\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1221245\n");
-    end
-    x = 64'h37F3488C88AB3C1E;
-    y = 64'hC0353E87080D3A0F;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1221859\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h8000000000000001;
-    z = 64'h406987D720CD2CFD;
-    ans = 64'h406987D720CD2CFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1222473\n");
-    end
-    x = 64'hFFE0000001FFFEFF;
-    y = 64'hC0C7FFFFFFFFFFFC;
-    z = 64'h480FF7FFFFFFF7FF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1223087\n");
-    end
-    x = 64'hBFE00000000EFFFF;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h8010000000000001;
-    ans = 64'h8007FFFFFFF88002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1223701\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hC6BFFFFBFFFFFFFE;
-    z = 64'h40000FFFFFFFFFEE;
-    ans = 64'hC6AFFFFC00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1224315\n");
-    end
-    x = 64'hBA0FFFFE000000FF;
-    y = 64'h8010000000000000;
-    z = 64'h5730000081FFFFFF;
-    ans = 64'h5730000081FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1224929\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h37E080000000000F;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1225543\n");
-    end
-    x = 64'h7FF000000001FFDF;
-    y = 64'hAE2FFFF7DFFFFFFE;
-    z = 64'hFFDE52E8C5C19871;
-    ans = 64'h7FF800000001FFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1226157\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1226771\n");
-    end
-    x = 64'h3FB0087FFFFFFFFE;
-    y = 64'h401009375F1B01C4;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FF4046F11216206;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1227385\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h402FF8001FFFFFFE;
-    ans = 64'h402FF8001FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1227999\n");
-    end
-    x = 64'h43FE00007FFFFFFF;
-    y = 64'hC3C04000001FFFFF;
-    z = 64'h801000FFC0000000;
-    ans = 64'hC7CE7800823BFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1228613\n");
-    end
-    x = 64'hB80C2C93CB9EB3AC;
-    y = 64'hBCA0000000000001;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h34BC2C93CB9EB3AE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1229227\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hC3FFFE000FFFFFFE;
-    z = 64'hB810000000000000;
-    ans = 64'hC3EFFE0010000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1229841\n");
-    end
-    x = 64'h4090000000220000;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hC000000800000008;
-    ans = 64'hC000000800000208;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1230455\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h47F0000020001000;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'h47E0000020001001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1231069\n");
-    end
-    x = 64'hB8007FFFFFFFBFFF;
-    y = 64'hC07FFFF80000000F;
-    z = 64'h41E7FFFFFFFFDFFF;
-    ans = 64'h41E7FFFFFFFFDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1231683\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hBFD0000000000001;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1232297\n");
-    end
-    x = 64'hC1E28F5AA84A2661;
-    y = 64'h408CC4DF0D0607D2;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'hC280AF9EBD1524C3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1232911\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h4D3BE3F191496943;
-    ans = 64'h4D3BE3F191496943;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1233525\n");
-    end
-    x = 64'hC1CFFFFFFFFF5FFF;
-    y = 64'h37F05C7808D8323D;
-    z = 64'h402DB1C05FC1A8CE;
-    ans = 64'h402DB1C05FC1A8CE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1234139\n");
-    end
-    x = 64'hFFEFF7F7FFFFFFFE;
-    y = 64'hBFE0000000000000;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1234753\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hB80000001FFFBFFE;
-    z = 64'h7FBDDD0E62681E3C;
-    ans = 64'h7FBDDD0E62681E3C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1235367\n");
-    end
-    x = 64'h39260035ABDD89AD;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h41EFDFBFFFFFFFFF;
-    ans = 64'h41EFDFBFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1235981\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h8000004000000003;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1236595\n");
-    end
-    x = 64'hC3CFFFFFFFEFFFFC;
-    y = 64'h3800000100000000;
-    z = 64'h0951CEBF00D210BB;
-    ans = 64'hBBE00000FFF7FFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1237209\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hBFF0000000000000;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401DFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1237823\n");
-    end
-    x = 64'h3CA0000007FFBFFF;
-    y = 64'h8003FFFFFFEFFFFF;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1238437\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hBFF0000000000001;
-    z = 64'hC7E00FFFFFFFFBFE;
-    ans = 64'hC7E00FFFFFFFFBFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1239051\n");
-    end
-    x = 64'hAC08231D9520F66E;
-    y = 64'h9D9AAF33D341D625;
-    z = 64'hBF3FFC0000000002;
-    ans = 64'hBF3FFC0000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1239665\n");
-    end
-    x = 64'hBFD035DDA176DAD8;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1240279\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hC7F0000102000000;
-    z = 64'hA7202000000007FF;
-    ans = 64'hC7E0000102000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1240893\n");
-    end
-    x = 64'h46218D1FD3FECF00;
-    y = 64'hC000000000000001;
-    z = 64'hB8100000000006FF;
-    ans = 64'hC6318D1FD3FECF01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1241507\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'h381FFFF000000FFF;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1242121\n");
-    end
-    x = 64'h471FFFC000000FFE;
-    y = 64'h37EFFF9FFFFFFFFE;
-    z = 64'h002FFFFC0000003F;
-    ans = 64'h3F1FFF6000C00FFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1242735\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h4010000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1243349\n");
-    end
-    x = 64'h41FB90A7E035BEF8;
-    y = 64'hB7EFFFFFFFF80200;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3C9FFFFFFFFFF91E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1243963\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hC010000000000000;
-    z = 64'hC3E51EE0A2AE97C7;
-    ans = 64'hC3E51EE0A2AE97C7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1244577\n");
-    end
-    x = 64'h3FDFFFFFBEFFFFFE;
-    y = 64'hF7D08BB81A011F46;
-    z = 64'hC3DF80000003FFFF;
-    ans = 64'hF7C08BB7F8655150;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1245191\n");
-    end
-    x = 64'h49AA8FD4E56A0F22;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1245805\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hC5FFFFFFFFFFBFFB;
-    z = 64'h801FFFFFFF7FFFDF;
-    ans = 64'hC5EFFFFFFFFFBFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1246419\n");
-    end
-    x = 64'h7FE007FFFFFFBFFF;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hFFE0000003FFE000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1247033\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hC3F4000400000000;
-    z = 64'hBFF0000000000001;
-    ans = 64'hC3E4000400000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1247647\n");
-    end
-    x = 64'hC05FFFFFFFFFFEFB;
-    y = 64'h402FFFFEF8000000;
-    z = 64'hC1D1000001000000;
-    ans = 64'hC1D1000200FFEF80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1248261\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h4000000000000001;
-    ans = 64'hC33FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1248875\n");
-    end
-    x = 64'hC330000000107FFE;
-    y = 64'h4340200000040000;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'hC68020000014A0FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1249489\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h43F1000004000000;
-    ans = 64'h43F0FE0004000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1250103\n");
-    end
-    x = 64'h402B03E8F7B08906;
-    y = 64'h412996BE0A0ABEA4;
-    z = 64'hC35FFFFFFCFFFFFF;
-    ans = 64'hC35FFFFFFCD4CB5D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1250717\n");
-    end
-    x = 64'h405FFFFFFFFFF007;
-    y = 64'hFFE0000000000001;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1251331\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hDF9FFFFFFFFFDFEF;
-    z = 64'hC03FFFFFFFFFE007;
-    ans = 64'hDF8FFFFFFFFFDFF1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1251945\n");
-    end
-    x = 64'hC1C54ECCB8C1D414;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hC3DFF7FFFFFFFDFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1252559\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hC00BFDFFFFFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hC005FF0000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1253173\n");
-    end
-    x = 64'hBFB2BDD6B4EE5235;
-    y = 64'h402FFFC00000001E;
-    z = 64'hBF91FDFFFFFFFFFE;
-    ans = 64'hBFF305A93940E86A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1253787\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hFFF0000000000001;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1254401\n");
-    end
-    x = 64'h347AFEC51BB8EC9A;
-    y = 64'h43D20E68A685DF5B;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h385E76ED3C9E9BCD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1255015\n");
-    end
-    x = 64'h3FE0000000000001;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hA41003FF80000000;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1255629\n");
-    end
-    x = 64'h0011000800000000;
-    y = 64'h4017797633517F39;
-    z = 64'hBF5F0000000003FF;
-    ans = 64'hBF5F0000000003FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1256243\n");
-    end
-    x = 64'h408FF7FFFF7FFFFF;
-    y = 64'h0000000000000000;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1256857\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h4030800000FFFFFF;
-    z = 64'h44200FFFFFFFFF7F;
-    ans = 64'h44200FFFFFFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1257471\n");
-    end
-    x = 64'hB7EC1C59B4C2E8E1;
-    y = 64'h0000000000000001;
-    z = 64'h00100000007FFE00;
-    ans = 64'h00100000007FFE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1258085\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hBE1FFFFFFFC0007E;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFE0000000FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1258699\n");
-    end
-    x = 64'h403000000001FFFB;
-    y = 64'hBFD340F99E89EBF4;
-    z = 64'hCDCBCAB1F16B5FD2;
-    ans = 64'hCDCBCAB1F16B5FD2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1259313\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h0010000000000000;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h3FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1259927\n");
-    end
-    x = 64'hBFBFFFFFC3FFFFFE;
-    y = 64'hBFB00800000FFFFE;
-    z = 64'h0000000000000000;
-    ans = 64'h3F8007FFE200FFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1260541\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h0010000000000001;
-    z = 64'hC34080FFFFFFFFFF;
-    ans = 64'hC34080FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1261155\n");
-    end
-    x = 64'hD03FF10000000000;
-    y = 64'h7FEA066340366A48;
-    z = 64'h3FBFFFFFFFF0000E;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1261769\n");
-    end
-    x = 64'h9C9FFF8000000100;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h4010000000000000;
-    ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1262383\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hC030000000101FFF;
-    z = 64'h4020400000010000;
-    ans = 64'hC01F8000003E7FFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1262997\n");
-    end
-    x = 64'hC1F00007FFFFFFC0;
-    y = 64'h3CA0000000000000;
-    z = 64'h3DD003FFFFFDFFFE;
-    ans = 64'hBE9FFF0FBFFFFFA0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1263611\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hCEFFFFC00007FFFF;
-    z = 64'hBFD0000000000000;
-    ans = 64'hCEFFFFC00007FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1264225\n");
-    end
-    x = 64'h205E03FFFFFFFFFF;
-    y = 64'h7FDB0898E3B7A8A5;
-    z = 64'h402750419179B0FB;
-    ans = 64'h60495B706898A50F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1264839\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1265453\n");
-    end
-    x = 64'hC000689C3D2EB143;
-    y = 64'h3C69E300BC404381;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1266067\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h3FD0000000000000;
-    z = 64'h40740CF10515C336;
-    ans = 64'h407410F10515C336;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1266681\n");
-    end
-    x = 64'hC1C0FFFFFFFFFFC0;
-    y = 64'h43E00FFFFFFFFFF8;
-    z = 64'hBFFFFFFFE0000007;
-    ans = 64'hC5B110FFFFFFFFB7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1267295\n");
-    end
-    x = 64'hC280000FFDFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h4000000000000001;
-    ans = 64'hC270000FFDFFDFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1267909\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h5D78B059EC0D3BA4;
-    z = 64'h7FD0000000009FFE;
-    ans = 64'h7FD0000000009FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1268523\n");
-    end
-    x = 64'hC3E1495E8BBE1289;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h4FB000047FFFFFFE;
-    ans = 64'h4FB000047FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1269137\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h480000000005FFFF;
-    z = 64'hBCA0000000000001;
-    ans = 64'h480000000005FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1269751\n");
-    end
-    x = 64'hB7EFFFFFFC000200;
-    y = 64'h705041FFFFFFFFFF;
-    z = 64'h3F23B0A5836E544A;
-    ans = 64'hE85041FFFDF7C103;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1270365\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FF3FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1270979\n");
-    end
-    x = 64'h4284920C713155BB;
-    y = 64'h4002F779DFFEC571;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1271593\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hC6522AF710929EDB;
-    ans = 64'hC6522AF710929EDB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1272207\n");
-    end
-    x = 64'hC077FFFFFFFFFFF7;
-    y = 64'h3FFE0000000FFFFE;
-    z = 64'hC1EFFFFFFFFF0001;
-    ans = 64'hC1F000002CFF8001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1272821\n");
-    end
-    x = 64'hFFDFFFFFFFF8003F;
-    y = 64'h3FF0000000000001;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'hFFDFFFFFFFF80041;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1273435\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hBC0FFFC0FFFFFFFF;
-    z = 64'h4004000000000001;
-    ans = 64'h4004000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1274049\n");
-    end
-    x = 64'h8A9FFFFEBFFFFFFE;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h37EFFC0000000800;
-    ans = 64'h37EFFC0000000800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1274663\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h43C800000FFFFFFE;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h43C800000FFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1275277\n");
-    end
-    x = 64'hBFEFFFFFFFFFFE07;
-    y = 64'h401658E0BF3B7A12;
-    z = 64'hBD5000004003FFFE;
-    ans = 64'hC01658E0BF3B79B1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1275891\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h4000000000000001;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1276505\n");
-    end
-    x = 64'hBF9DFE4AA0DF2EF9;
-    y = 64'h3FB01000000001FF;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1277119\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hBFF00020001FFFFF;
-    ans = 64'h4007FFEFFFEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1277733\n");
-    end
-    x = 64'hBEFFFFFB7FFFFFFF;
-    y = 64'h3FF2A08A53EA01BD;
-    z = 64'hDB700007FFFFFDFE;
-    ans = 64'hDB700007FFFFFDFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1278347\n");
-    end
-    x = 64'hC340000001FFFBFF;
-    y = 64'h4010000000000000;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'hC360000001FFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1278961\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h37F0F632AC29B9C3;
-    z = 64'h3FF0007FFFFFF7FF;
-    ans = 64'h3FF0007FFFFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1279575\n");
-    end
-    x = 64'h3FEB152BF5A33E69;
-    y = 64'h4010000000000001;
-    z = 64'h3800400000004000;
-    ans = 64'h400B152BF5A33E6B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1280189\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h43C02D27FC4AB999;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h43C02D27FC4AB998;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1280803\n");
-    end
-    x = 64'h411FFFFFFF80FFFF;
-    y = 64'hC1FFFFFFFFF7F7FF;
-    z = 64'h373C000400000000;
-    ans = 64'hC32FFFFFFF78F7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1281417\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h4340000000000000;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h433FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1282031\n");
-    end
-    x = 64'hBF900000003FFFFE;
-    y = 64'h3FA081FFFFFFFFFF;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1282645\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h4340000000000001;
-    z = 64'hC1EFC0003FFFFFFF;
-    ans = 64'h433FFFFF01FFFE01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1283259\n");
-    end
-    x = 64'h3FD0020020000000;
-    y = 64'h4B50000010000007;
-    z = 64'h41E00FFFFFFFBFFF;
-    ans = 64'h4B30020030020027;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1283873\n");
-    end
-    x = 64'hB7EFFFFBFFFFFFF7;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1284487\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hC133A27B1EA10710;
-    z = 64'h47E1000200000000;
-    ans = 64'h47E1000200000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1285101\n");
-    end
-    x = 64'h40500008001FFFFF;
-    y = 64'h7FE0000000000000;
-    z = 64'h3DC0007BFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1285715\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hC20EBA2FF0240962;
-    z = 64'h8000000000000000;
-    ans = 64'hC20EBA2FF0240961;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1286329\n");
-    end
-    x = 64'h41F0000000FFFF80;
-    y = 64'hBFB00000800003FE;
-    z = 64'h406FFF80000007FF;
-    ans = 64'hC1AFFFFF0208070C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1286943\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h0010000000000000;
-    ans = 64'h7FEFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1287557\n");
-    end
-    x = 64'h40200000007FFEFE;
-    y = 64'hBF90000000FFDFFF;
-    z = 64'hC010000000000001;
-    ans = 64'hC0108000000BFEF9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1288171\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h7FF0000000000000;
-    z = 64'h41E8000000000080;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1288785\n");
-    end
-    x = 64'h4340000000010001;
-    y = 64'h380FFFFFFFDEFFFF;
-    z = 64'h301000000000207F;
-    ans = 64'h3B5FFFFFFFE10001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1289399\n");
-    end
-    x = 64'h40AFFFBFFFFE0000;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h3FD0000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1290013\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hBCA7FFFFFFFFFEFF;
-    z = 64'h070FE00000000800;
-    ans = 64'hBCA7FFFFFFFFFEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1290627\n");
-    end
-    x = 64'hF5FFFFFFFDDFFFFF;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h5D8FFFFFFDFFFFFD;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1291241\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hBFEC736A2BE2AD7C;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1291855\n");
-    end
-    x = 64'hBFE80000001FFFFE;
-    y = 64'h4014000000200000;
-    z = 64'h41CE092D9BE1AC67;
-    ans = 64'h41CE092D9A01AC67;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1292469\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h0000000000000001;
-    ans = 64'h800FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1293083\n");
-    end
-    x = 64'hBF30004000000008;
-    y = 64'h41CFFBFFEFFFFFFE;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC10FFC9FDFFFC00E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1293697\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'hA250000000000802;
-    ans = 64'hA250000000000802;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1294311\n");
-    end
-    x = 64'h5650000007FF7FFF;
-    y = 64'hBF0FFFFFFDBFFFFE;
-    z = 64'h7FE0000000FFFEFF;
-    ans = 64'h7FE0000000FFFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1294925\n");
-    end
-    x = 64'hBE2000000000006F;
-    y = 64'h8010000000000001;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1295539\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h384007FFFE000000;
-    z = 64'hBF8801FFFFFFFFFE;
-    ans = 64'hBF8801FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1296153\n");
-    end
-    x = 64'h3C48C93EA9A07ED5;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hBFF0000FFFFFFFEF;
-    ans = 64'hBFF0000FFFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1296767\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h4E30000200FFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1297381\n");
-    end
-    x = 64'hB7FBD8C8068C6E0C;
-    y = 64'h3EC0CCF1D11F2D71;
-    z = 64'h37E1FFFFFFFEFFFE;
-    ans = 64'h37E1FFF8B0A0C977;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1297995\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hBCA0000000000000;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1298609\n");
-    end
-    x = 64'h41A01BFFFFFFFFFF;
-    y = 64'hB14000000100001E;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1299223\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h8A5100000007FFFE;
-    ans = 64'hBCAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1299837\n");
-    end
-    x = 64'hC02CF7239E657AB3;
-    y = 64'hC02133A02874B10A;
-    z = 64'hC340000020000003;
-    ans = 64'hC34000001FFFFFC5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1300451\n");
-    end
-    x = 64'hC01FFEFFE0000000;
-    y = 64'hBFD0000000000000;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h3FFFFEFFE0000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1301065\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hC0000000001FDFFF;
-    z = 64'h3FB0200000000004;
-    ans = 64'hBFFEFE00003FBFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1301679\n");
-    end
-    x = 64'hC3F000000013FFFF;
-    y = 64'hBFD0000000000001;
-    z = 64'hFFFFEFFFFFFFE000;
-    ans = 64'hFFFFEFFFFFFFE000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1302293\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h97800000000007FE;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1302907\n");
-    end
-    x = 64'hC8002250949885EE;
-    y = 64'hBDD0000000400002;
-    z = 64'h38B08007FFFFFFFE;
-    ans = 64'h45E0225094D90F32;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1303521\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1304135\n");
-    end
-    x = 64'h7FF020FFFFFFFFFE;
-    y = 64'h4B1007FFFFFFFDFF;
-    z = 64'hBFF0000000000000;
-    ans = 64'h7FF820FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1304749\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hBFE0000000000001;
-    z = 64'h19CD37F4AB573BAD;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1305363\n");
-    end
-    x = 64'h3FD7F4759BBC33AC;
-    y = 64'h0001FFF7FFFFFFFE;
-    z = 64'hC47A74EAEF324D40;
-    ans = 64'hC47A74EAEF324D40;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1305977\n");
-    end
-    x = 64'hC4300000000801FF;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h0010000000000000;
-    ans = 64'h44300000000801FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1306591\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hC3E9F02373D523CF;
-    z = 64'h434FFFFFFFDFFF7E;
-    ans = 64'hC3E9E82373D52BCE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1307205\n");
-    end
-    x = 64'h3FB8102FC1161058;
-    y = 64'hBFF0000000000000;
-    z = 64'h471FFFFFFFFFBFF7;
-    ans = 64'h471FFFFFFFFFBFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1307819\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hC0A9793A9BECD88F;
-    z = 64'h4340000000000000;
-    ans = 64'h433FFFFFFFFFF343;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1308433\n");
-    end
-    x = 64'hC7FFDFFFFFBFFFFF;
-    y = 64'hC390000003FFFFFD;
-    z = 64'hBF4FFFFFF000FFFE;
-    ans = 64'h4B9FE00007B7FFF9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1309047\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1309661\n");
-    end
-    x = 64'hB6C7632F24A774E2;
-    y = 64'hBFC000200000001F;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1310275\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hC000000000000000;
-    z = 64'hC177FCA22F433E8D;
-    ans = 64'hC177FCA24F433E8D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1310889\n");
-    end
-    x = 64'hC1CFFFFFFFFFF5FF;
-    y = 64'hBFB0000000FFFDFE;
-    z = 64'h3FAFFFFE00000040;
-    ans = 64'h41900000013FF8F9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1311503\n");
-    end
-    x = 64'h45CFE0000000007F;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h0000000000000001;
-    ans = 64'hC5EFE0000000007E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1312117\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h801A837F2AE19C47;
-    z = 64'h4020800000000007;
-    ans = 64'h4020800000000007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1312731\n");
-    end
-    x = 64'hC7FFFFC000000001;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hC3C0F052C00D8DA7;
-    ans = 64'h481FFFBFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1313345\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hC1E16294F17A2FC0;
-    z = 64'h4010000000000001;
-    ans = 64'hC1E16294F0FA2FBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1313959\n");
-    end
-    x = 64'hBCBC000000000000;
-    y = 64'h4100000001040000;
-    z = 64'h401000FFFFFFE000;
-    ans = 64'h401000FFFFFF0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1314573\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hC010000000000001;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1315187\n");
-    end
-    x = 64'h3F70000000201FFF;
-    y = 64'h363008000000FFFF;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1315801\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hC3471DB14B06DAD6;
-    ans = 64'hC3471DB14B06DADA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1316415\n");
-    end
-    x = 64'hC1FF3AD94ADF7008;
-    y = 64'h3FCF000000000002;
-    z = 64'hC071000000000200;
-    ans = 64'hC1DE4102C488748A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1317029\n");
-    end
-    x = 64'hEEBE30496FC34DC3;
-    y = 64'hC340000000000000;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1317643\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hBFDFF8000003FFFF;
-    z = 64'h9DBFFFFE003FFFFF;
-    ans = 64'hBFDFF8000003FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1318257\n");
-    end
-    x = 64'h401C285C5FADB760;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hBA5FFFFE0000003F;
-    ans = 64'hC37C285C5FADB75F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1318871\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h3B70000400FFFFFF;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1319485\n");
-    end
-    x = 64'h40100FFFFFFFFFFE;
-    y = 64'h14B0001FFFFFFFFF;
-    z = 64'hC1C02FFFFFFFFFFF;
-    ans = 64'hC1C02FFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1320099\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hFFE0000000000000;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hFFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1320713\n");
-    end
-    x = 64'hAEF00000047FFFFF;
-    y = 64'hC017FFFFFFFFFFFC;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBCAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1321327\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hBFC0100000400000;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1321941\n");
-    end
-    x = 64'hC1E0000000400100;
-    y = 64'h355FFFF80000007F;
-    z = 64'h41D359926AF53F43;
-    ans = 64'h41D359926AF53F43;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1322555\n");
-    end
-    x = 64'h480000000001FF7E;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1323169\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hE06FFFFFFF00001E;
-    z = 64'h3E2EE32E2DA9DA61;
-    ans = 64'hE06FFFFFFF00001D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1323783\n");
-    end
-    x = 64'hBE843F1957410156;
-    y = 64'hFFF0000000000001;
-    z = 64'h0000020000001000;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1324397\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'h43FFFFFFC0000400;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h43FFFFFFC00003FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1325011\n");
-    end
-    x = 64'h3FBFFFFF000003FE;
-    y = 64'hBFF007FFFFC00000;
-    z = 64'h3FA0000000001008;
-    ans = 64'hBFB80FFEFEFFFC00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1325625\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1326239\n");
-    end
-    x = 64'h41C4A5EB10FE5857;
-    y = 64'h402FFFFFFE0001FF;
-    z = 64'hBCA0000000000000;
-    ans = 64'h4204A5EB0FB3FAF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1326853\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h0000000000000001;
-    z = 64'h28D30F43996477D5;
-    ans = 64'h28D30F43996477D5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1327467\n");
-    end
-    x = 64'h6DB0000004000001;
-    y = 64'hBFCE75F930ACC3A2;
-    z = 64'hC1EFFFFFE1FFFFFF;
-    ans = 64'hED8E75F9384A41F0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1328081\n");
-    end
-    x = 64'hBFEF7FFFFFFBFFFF;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1328695\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h4020000000800008;
-    z = 64'hC80FF807FFFFFFFF;
-    ans = 64'hC80FF807FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1329309\n");
-    end
-    x = 64'h433FFFFFF0000008;
-    y = 64'h0010000000000000;
-    z = 64'h47EFF00000000100;
-    ans = 64'h47EFF00000000100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1329923\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h43F003FFFFE00000;
-    z = 64'h3FF0000000000000;
-    ans = 64'h43F003FFFFDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1330537\n");
-    end
-    x = 64'hC0200000000200FF;
-    y = 64'hBFC000000007FFE0;
-    z = 64'hFD10207FFFFFFFFE;
-    ans = 64'hFD10207FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1331151\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1331765\n");
-    end
-    x = 64'hAEA2D2DFA3D2A4D3;
-    y = 64'hC1700080000007FF;
-    z = 64'h8010000000000001;
-    ans = 64'h3022D3763ACFCCD0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1332379\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h3CA0000000000000;
-    z = 64'h4A83FFFFBFFFFFFE;
-    ans = 64'h4A83FFFFBFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1332993\n");
-    end
-    x = 64'hB5A541B1DC1A499A;
-    y = 64'h3DDFFFF000000080;
-    z = 64'h8010D30DDE0007DB;
-    ans = 64'hB39541A73B415BE2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1333607\n");
-    end
-    x = 64'h3D0FFFFFFFFFF010;
-    y = 64'h3CA0000000000001;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1334221\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h3FC004000000003E;
-    z = 64'h47F742E3F90D4517;
-    ans = 64'h47F742E3F90D4517;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1334835\n");
-    end
-    x = 64'h8FBFF78000000000;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hC1F8000000000400;
-    ans = 64'hC1F8000000000400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1335449\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h43FFFFFFF801FFFE;
-    z = 64'h3FE0000000000001;
-    ans = 64'h43FFFFFFF801FFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1336063\n");
-    end
-    x = 64'h4063FFFFFFFF0000;
-    y = 64'hC39FFFFFF8000000;
-    z = 64'h3FDDFFFFEFFFFFFF;
-    ans = 64'hC413FFFFFAFF0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1336677\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h3FD0000000000001;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFE8000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1337291\n");
-    end
-    x = 64'h484FFFFFFEFFDFFE;
-    y = 64'h43DFFFFFFFFFFFFA;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h4C3FFFFFFEFFDFF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1337905\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hBFFAADFFB24BA446;
-    ans = 64'hBFF2ADFFB24BA447;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1338519\n");
-    end
-    x = 64'h3CDFFFFFFFFFFE1F;
-    y = 64'h406000FFFFC00000;
-    z = 64'h39D8B0F072271B05;
-    ans = 64'h3D5000FFFFBFFF10;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1339133\n");
-    end
-    x = 64'hC3FC000003FFFFFF;
-    y = 64'h3FE0000000000000;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC3EC000003FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1339747\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hCA6F7FFFFFFFDFFF;
-    z = 64'hCAEDFFFFFFF7FFFF;
-    ans = 64'hCAEE1F7FFFF7FFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1340361\n");
-    end
-    x = 64'hC1C0100000001FFE;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'hBC0F7F3C05E5F2B0;
-    ans = 64'hC1C0100000001FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1340975\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hA4638C58500B961E;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1341589\n");
-    end
-    x = 64'h2EF200000000FFFF;
-    y = 64'h3CA0800003FFFFFF;
-    z = 64'hBFC8001000000000;
-    ans = 64'hBFC8001000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1342203\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h3FF0000000000000;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1342817\n");
-    end
-    x = 64'hBFE118C580AAF9EC;
-    y = 64'h000F808000000000;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1343431\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hA79000000003FF7F;
-    ans = 64'h3FFFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1344045\n");
-    end
-    x = 64'h401FFDFFFFEFFFFE;
-    y = 64'h0AD00000000003EE;
-    z = 64'hA4CBFFFFFFFFFF7F;
-    ans = 64'hA4CBFFFFFFFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1344659\n");
-    end
-    x = 64'h4D4000000000201F;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'h4D5000000000201E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1345273\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hD69C0000000000FF;
-    z = 64'h43D00000000007FC;
-    ans = 64'hD69C0000000000FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1345887\n");
-    end
-    x = 64'hBF95B034FF94FE5C;
-    y = 64'h4000000000000001;
-    z = 64'h40BCE22B0AAE2F5F;
-    ans = 64'h40BCE2203293AF95;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1346501\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hE8240000000FFFFF;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'hE8240000000FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1347115\n");
-    end
-    x = 64'h0C1E96E5A8F1725B;
-    y = 64'h41FF800000003FFF;
-    z = 64'h3FDF000100000000;
-    ans = 64'h3FDF000100000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1347729\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'h400BFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1348343\n");
-    end
-    x = 64'hCFBFFF00000FFFFF;
-    y = 64'h40DC8DDCCA9532BF;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1348957\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h4010000000000001;
-    z = 64'h409FFF7FFFDFFFFE;
-    ans = 64'h40A007BFFFEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1349571\n");
-    end
-    x = 64'hB7F000000000FFF7;
-    y = 64'h7FD00003FFFFFFEF;
-    z = 64'h4110004040000000;
-    ans = 64'hF7D000040000FFE6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1350185\n");
-    end
-    x = 64'hFFEFFDFFFFFE0000;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hC000000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1350799\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h3FEFF00000000FFF;
-    z = 64'h41FFFFFDFFFFF7FF;
-    ans = 64'h41FFFFFE000FEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1351413\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFF7;
-    y = 64'h4340000000000000;
-    z = 64'hBB4FFFFBFFFFE000;
-    ans = 64'h434FFFFFFFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1352027\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h3D20000007FFFFFE;
-    z = 64'h3CA0000000000000;
-    ans = 64'h3D20100007FFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1352641\n");
-    end
-    x = 64'h3C10004003FFFFFF;
-    y = 64'h3F0D38A39B792D42;
-    z = 64'h002C000000FFFFFF;
-    ans = 64'h3B2D39188555C40C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1353255\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hBFD0000000000000;
-    ans = 64'h434FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1353869\n");
-    end
-    x = 64'hBFCFFF8000FFFFFF;
-    y = 64'h000F800000000007;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1354483\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h7FE0000000000000;
-    z = 64'h480FFF0003FFFFFE;
-    ans = 64'h7FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1355097\n");
-    end
-    x = 64'hC0100401FFFFFFFF;
-    y = 64'h47F479040FA5F423;
-    z = 64'hC0A638D6A77E342F;
-    ans = 64'hC8147E24DFCA5F93;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1355711\n");
-    end
-    x = 64'h47F0007FF8000000;
-    y = 64'h7FE0000000000001;
-    z = 64'hBFF0000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1356325\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h403E000001FFFFFF;
-    z = 64'h4020008000000000;
-    ans = 64'h4043002000FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1356939\n");
-    end
-    x = 64'hC550008000007FFE;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h3F80000010000800;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1357553\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h469FFFEFFFFFFFBE;
-    z = 64'h0010000000000001;
-    ans = 64'h469FFFEFFFFFFFBC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1358167\n");
-    end
-    x = 64'h401FFFF7FFFFFFFA;
-    y = 64'h40CF9BE39E1FA5EE;
-    z = 64'hB80010000003FFFF;
-    ans = 64'h40FF9BDBB726BE60;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1358781\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h7FF0000000000001;
-    z = 64'hBCA0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1359395\n");
-    end
-    x = 64'h3FD00003FBFFFFFF;
-    y = 64'h7FEFFFFFFFE07FFE;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h7FD00003FBF03FFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1360009\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'hBCAFFFEFFFFFFF7F;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1360623\n");
-    end
-    x = 64'h4020040000100000;
-    y = 64'hF7601000000000FF;
-    z = 64'h41CFFFFFFFFFBFE0;
-    ans = 64'hF7901404001010FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1361237\n");
-    end
-    x = 64'hD927210495182481;
-    y = 64'h8000000000000000;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1361851\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h381FFFFFFFFBFFFF;
-    z = 64'h3FC0100001FFFFFF;
-    ans = 64'h3FC0100001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1362465\n");
-    end
-    x = 64'hD741116F2A3365CB;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hC06000001FC00000;
-    ans = 64'hC06000001FC00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1363079\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hBFD00000007FFFFD;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hBFD00000007FFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1363693\n");
-    end
-    x = 64'hC1F000007EFFFFFF;
-    y = 64'hC3DFFFFFFFDFFEFF;
-    z = 64'hC34C07FFFFFFFFFE;
-    ans = 64'h45E000007EEFF87C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1364307\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h8010000000000000;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h8027FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1364921\n");
-    end
-    x = 64'hFFDD48F3ED90B012;
-    y = 64'hC26FFF83FFFFFFFE;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1365535\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h800007FFFFFBFFFE;
-    ans = 64'h802003FFFFFDFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1366149\n");
-    end
-    x = 64'hC3FF3FFFFFFFFFFE;
-    y = 64'h43DFFFFDFFFF7FFF;
-    z = 64'hB4FFFFBFBFFFFFFF;
-    ans = 64'hC7EF3FFE0BFF82FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1366763\n");
-    end
-    x = 64'hC01FFFFFFAFFFFFF;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1367377\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hC01000FFFFFEFFFF;
-    z = 64'hC34FFFFFFFF803FE;
-    ans = 64'hC34FFFFFFFF80400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1367991\n");
-    end
-    x = 64'h40B00000001FFBFF;
-    y = 64'hBCA0000000000001;
-    z = 64'hC1F000007FBFFFFE;
-    ans = 64'hC1F000007FBFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1368605\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h413EFFF800000000;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1369219\n");
-    end
-    x = 64'hC6300001000FFFFF;
-    y = 64'h434FFFFFFFC0007F;
-    z = 64'h3FFFFFFFFFFFEFEF;
-    ans = 64'hC9900000FFF0003C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1369833\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hBCAFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1370447\n");
-    end
-    x = 64'h4AAF000007FFFFFF;
-    y = 64'h0004977D373AAD6E;
-    z = 64'h4010000000000000;
-    ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1371061\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hBFD0000000000001;
-    z = 64'hBE1001FFFFDFFFFF;
-    ans = 64'hBFD0000001002000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1371675\n");
-    end
-    x = 64'hBABFF7FFFDFFFFFF;
-    y = 64'hB9B31D4215104245;
-    z = 64'hBFD9CAF56DFECE0A;
-    ans = 64'hBFD9CAF56DFECE0A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1372289\n");
-    end
-    x = 64'h3CA0000000008007;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1372903\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h00200000000001FC;
-    z = 64'h3F741AB531AC27FD;
-    ans = 64'h3F741AB531AC27FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1373517\n");
-    end
-    x = 64'hC3D000000000407F;
-    y = 64'hBFE0000000000000;
-    z = 64'hBFD1FFFFFFEFFFFF;
-    ans = 64'h43C000000000407F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1374131\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hC6B0000040000008;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1374745\n");
-    end
-    x = 64'hBFDFFF7FFFFFBFFF;
-    y = 64'h7DA199373DE9FB0D;
-    z = 64'h00200001FFFFFFFA;
-    ans = 64'hFD9198F0D90CE032;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1375359\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h8000000000000000;
-    ans = 64'hBFEFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1375973\n");
-    end
-    x = 64'h3CFD9E68D58E5F29;
-    y = 64'h430F52E00863ED5B;
-    z = 64'h4000000000000001;
-    ans = 64'h40227F156C138BF2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1376587\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hBFF0000000000000;
-    z = 64'hC3D00000000000BF;
-    ans = 64'hC3D00000000000BF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1377201\n");
-    end
-    x = 64'hC1E4000000800000;
-    y = 64'hE56FC00000000008;
-    z = 64'hC5B036279681DACA;
-    ans = 64'h6763D800007F0005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1377815\n");
-    end
-    x = 64'h4033A8D422040365;
-    y = 64'hBFF0000000000001;
-    z = 64'hBCA0000000000001;
-    ans = 64'hC033A8D422040366;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1378429\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hBCE0000040000000;
-    z = 64'hC340000000040007;
-    ans = 64'hC340000000040007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1379043\n");
-    end
-    x = 64'hBFFF800400000000;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h8A809F84BB94C49F;
-    ans = 64'h400F8003FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1379657\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hC03FFFFFFFF0FFFF;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1380271\n");
-    end
-    x = 64'hC1FF310B7E90EE8B;
-    y = 64'hC02FFFFFFBBFFFFF;
-    z = 64'hC1F94758E83D6556;
-    ans = 64'h423D9C95EBE894AE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1380885\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hC000000000000001;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1381499\n");
-    end
-    x = 64'h7FF0656055BFCC7D;
-    y = 64'hB9D00001FFFFFFFC;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h7FF8656055BFCC7D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1382113\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h3FD000800000007F;
-    ans = 64'hC00DFFEFFFFFFFEC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1382727\n");
-    end
-    x = 64'hBFCFFC00FFFFFFFF;
-    y = 64'hC01FFFBFFFBFFFFE;
-    z = 64'h41DFFFFFFFFFFFFF;
-    ans = 64'h41E00000003FF782;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1383341\n");
-    end
-    x = 64'hFFD82E04A44D5219;
-    y = 64'hC010000000000000;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1383955\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h41D0000004007FFF;
-    z = 64'h47EFFF7FFFFFBFFF;
-    ans = 64'h47EFFF7FFFFFBFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1384569\n");
-    end
-    x = 64'h47FFFFFFFFFFFFE8;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h7FD002000000007F;
-    ans = 64'h7FD002000000007F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1385183\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h43DFFFFFFFFC0007;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'h43DFEFFFFFFC0005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1385797\n");
-    end
-    x = 64'h800BBE3863B0D8E2;
-    y = 64'h8D1C310F19AC6C6C;
-    z = 64'h29A000000001F7FF;
-    ans = 64'h29A000000001F7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1386411\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hC340000000000000;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1387025\n");
-    end
-    x = 64'h40540000001FFFFF;
-    y = 64'h7AAAE17574EE89CD;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h7B10CCE9692FF795;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1387639\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hC340000000000001;
-    z = 64'hBE3774044EEB60EB;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1388253\n");
-    end
-    x = 64'hA0439A60C9F683F6;
-    y = 64'hC00FFFFFEFEFFFFE;
-    z = 64'hC7E01000000000FF;
-    ans = 64'hC7E01000000000FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1388867\n");
-    end
-    x = 64'h400000000001FDFF;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hC36000000001FDFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1389481\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h41EFFB7FFFFFFFFE;
-    z = 64'h7FE0000001FF0000;
-    ans = 64'h7FE0000001FF0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1390095\n");
-    end
-    x = 64'hBCBFFFFF7FFFFFFF;
-    y = 64'hFFE0000000000001;
-    z = 64'hBFEFEFFFFFFFFF7F;
-    ans = 64'h7CAFFFFF80000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1390709\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hC3E0000000000000;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC3DFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1391323\n");
-    end
-    x = 64'h400B23CD9F2D28D3;
-    y = 64'h43E00003FFF7FFFF;
-    z = 64'hB8101BFFFFFFFFFF;
-    ans = 64'h43FB23D46812FEB6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1391937\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1392551\n");
-    end
-    x = 64'h2CCFFFFFF9000000;
-    y = 64'h3E6FFFFFFF000FFF;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1393165\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'hFFF0000000000000;
-    z = 64'h800905798199477F;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1393779\n");
-    end
-    x = 64'hB7FFFFFFFFF5FFFF;
-    y = 64'hBFCFFFFFFF7FFFFC;
-    z = 64'hC60FDFFFFFFFDFFF;
-    ans = 64'hC60FDFFFFFFFDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1394393\n");
-    end
-    x = 64'hD8FF800000000000;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h8000000000000000;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1395007\n");
-    end
-    x = 64'h3FEFFFFFFFFFFFFE;
-    y = 64'h3FB058526BA0D257;
-    z = 64'h800FFFFE0000007E;
-    ans = 64'h3FB058526BA0D256;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1395621\n");
-    end
-    x = 64'hB81002000000000E;
-    y = 64'h0000000000000000;
-    z = 64'hBC7C2C58541F1160;
-    ans = 64'hBC7C2C58541F1160;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1396235\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hBF1FFFFF7F7FFFFF;
-    z = 64'hC010000000000000;
-    ans = 64'hC010001FFFFF7F80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1396849\n");
-    end
-    x = 64'hC768FA865408D1D8;
-    y = 64'h3D9294A5362769E9;
-    z = 64'h43FFFFE0000001FE;
-    ans = 64'hC50D01D665378D9E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1397463\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1398077\n");
-    end
-    x = 64'hB4DCF901BB92E4A0;
-    y = 64'h3E2FEDFFFFFFFFFF;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1398691\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h3D500008000007FE;
-    ans = 64'h3D500008000007FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1399305\n");
-    end
-    x = 64'h41FDFFFFFFFFFFEF;
-    y = 64'h606BF7FFFFFFFFFE;
-    z = 64'h41DCFE3F1CFBA018;
-    ans = 64'h627A387FFFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1399919\n");
-    end
-    x = 64'h4020000804000000;
-    y = 64'h0010000000000001;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1400533\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h8A10800000000003;
-    z = 64'hBD0FF000FFFFFFFF;
-    ans = 64'hBD0FF000FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1401147\n");
-    end
-    x = 64'h402FFFFFFF800002;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hC3C8EA6925A562CF;
-    ans = 64'hC3C8EA6925A562CF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1401761\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h381FFEFFFFFFFFFD;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1402375\n");
-    end
-    x = 64'h41C03474E092DF19;
-    y = 64'hB887A3DBAEE7821E;
-    z = 64'h43D0000004000003;
-    ans = 64'h43D0000004000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1402989\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h3CA0000000000001;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1403603\n");
-    end
-    x = 64'h3CAFFFFFFF00007E;
-    y = 64'hCABFFFFFEFFBFFFE;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'hC77FFFFFEEFC007D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1404217\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hAB4FFFFFFFDFFDFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1404831\n");
-    end
-    x = 64'hBFEFFFC0001FFFFF;
-    y = 64'hC390040000000000;
-    z = 64'h7FF0000000000060;
-    ans = 64'h7FF8000000000060;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1405445\n");
-    end
-    x = 64'hEE6001FFFDFFFFFE;
-    y = 64'h3FD0000000000000;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1406059\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h400000000FEFFFFF;
-    z = 64'h37D3F51830BDE67E;
-    ans = 64'h400000000FEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1406673\n");
-    end
-    x = 64'hBFF9733FD96151F8;
-    y = 64'h3FD0000000000001;
-    z = 64'h7FD9EFD6C4A0DA0E;
-    ans = 64'h7FD9EFD6C4A0DA0E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1407287\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h480EF55E4C511072;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'h480EF55E4C511072;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1407901\n");
-    end
-    x = 64'hEDD07FFC00000000;
-    y = 64'h0CDE33B29AF512B6;
-    z = 64'h7FF0000000800080;
-    ans = 64'h7FF8000000800080;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1408515\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h3FE0000000000000;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h4012000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1409129\n");
-    end
-    x = 64'h7FEFFFFFFFE7FFFF;
-    y = 64'h403000FFFFFFFF7F;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1409743\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h3FE0000000000001;
-    z = 64'hC7FFFFFFFF8007FF;
-    ans = 64'hC7FFFFFFFF8007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1410357\n");
-    end
-    x = 64'hC1EFFFFE007FFFFF;
-    y = 64'h7E5F7FFFFF000000;
-    z = 64'hC048000001000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1410971\n");
-    end
-    x = 64'h000FFEEFFFFFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1411585\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h41AFFFC000FFFFFF;
-    z = 64'hBFFFFFFE000001FF;
-    ans = 64'h41AFFFBFFD00003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1412199\n");
-    end
-    x = 64'h43CFF740660B0295;
-    y = 64'h3FF0000000000000;
-    z = 64'h3FC97D303536B448;
-    ans = 64'h43CFF740660B0295;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1412813\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h380FEFFFFFFFFF80;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1413427\n");
-    end
-    x = 64'h4511DFFFFFFFFFFF;
-    y = 64'h401000000010007E;
-    z = 64'h001FBFFFFFFFFFFE;
-    ans = 64'h4531E0000011E08C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1414041\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1414655\n");
-    end
-    x = 64'hC46FFFFFF801FFFF;
-    y = 64'h5F5FFFFFFC00FFFF;
-    z = 64'h0010000000000000;
-    ans = 64'hE3DFFFFFF402FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1415269\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h4000000000000000;
-    z = 64'h36E02000000003FF;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1415883\n");
-    end
-    x = 64'h802FFFFFFFFDFDFF;
-    y = 64'hA1620FFFFFFFFFFE;
-    z = 64'h3FFFFFFFBFFFFEFE;
-    ans = 64'h3FFFFFFFBFFFFEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1416497\n");
-    end
-    x = 64'hC1DE99F9DE1E2571;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h4340000000000000;
-    ans = 64'h433FFFFE1660621E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1417111\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h919FFFFFDFBFFFFF;
-    z = 64'h4A9FFFF7FFFF0000;
-    ans = 64'h4A9FFFF7FFFF0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1417725\n");
-    end
-    x = 64'hDB31E4BC02F84EE3;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h40000003FFBFFFFE;
-    ans = 64'hDB51E4BC02F84EE2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1418339\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h3806052FB3CF6049;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1418953\n");
-    end
-    x = 64'hC7F0000003F00000;
-    y = 64'hBF3EFFFFFFFFFFDE;
-    z = 64'hBF9FFFFFF7FFFFFB;
-    ans = 64'h473F000007A0FFDE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1419567\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h3FF0000000000000;
-    ans = 64'h4022000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1420181\n");
-    end
-    x = 64'h7FDFFFFDFFFFFEFF;
-    y = 64'hC2D5D0A345929279;
-    z = 64'h0000000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1420795\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h3FF0001FFFFF7FFE;
-    ans = 64'h40220003FFFFEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1421409\n");
-    end
-    x = 64'hC023FFFFFF7FFFFF;
-    y = 64'h000FFFFEEFFFFFFF;
-    z = 64'hC1801FF000000000;
-    ans = 64'hC1801FF000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1422023\n");
-    end
-    x = 64'h3FD8BF5AE69162C4;
-    y = 64'h4340000000000001;
-    z = 64'h4010000000000001;
-    ans = 64'h4328BF5AE69162CE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1422637\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h4070041FFFFFFFFE;
-    z = 64'hBD807FFFFFFFFFFF;
-    ans = 64'h4070041FFFFFFFDD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1423251\n");
-    end
-    x = 64'hB7EFFFFEFEFFFFFF;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h816FFFFFFFFFF07E;
-    ans = 64'hBB4FFFFEFEFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1423865\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h47FBFFDFFFFFFFFF;
-    z = 64'hBFD0000000000001;
-    ans = 64'h47FBFFDFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1424479\n");
-    end
-    x = 64'h000BC447665234B1;
-    y = 64'hC1E00000020007FE;
-    z = 64'hC37FFFFFF87FFFFF;
-    ans = 64'hC37FFFFFF87FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1425093\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h7FE0000000000001;
-    z = 64'h3FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1425707\n");
-    end
-    x = 64'hC0CF5CA46D9DFF8A;
-    y = 64'h43D00000004001FF;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1426321\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hC2B20000003FFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1426935\n");
-    end
-    x = 64'h283FFFC0000FFFFF;
-    y = 64'h47EFC01FFFFFFFFE;
-    z = 64'hC1D3A57182FEF829;
-    ans = 64'hC1D3A57182FEF829;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1427549\n");
-    end
-    x = 64'hBA700010007FFFFF;
-    y = 64'h7FF0000000000000;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1428163\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h48000FFFFBFFFFFF;
-    z = 64'h000FFFC000020000;
-    ans = 64'h48000FFFFBFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1428777\n");
-    end
-    x = 64'h3CAFF80000003FFF;
-    y = 64'h7FF0000000000001;
-    z = 64'h3FB03FFFFFFFFBFE;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1429391\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h3FEC0000000001FE;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'h3FEC0000000001FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1430005\n");
-    end
-    x = 64'h4AD000020007FFFF;
-    y = 64'h419FFF80000003FE;
-    z = 64'hBCAFFBFFFFFFFBFF;
-    ans = 64'h4C7FFF84000003BC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1430619\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h8000000000000000;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1431233\n");
-    end
-    x = 64'h800D1E2B38A9119F;
-    y = 64'h434F7FF800000000;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1431847\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h8000000000000001;
-    z = 64'h3B61E24154BF7903;
-    ans = 64'h3B61E24154BF7903;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1432461\n");
-    end
-    x = 64'hBFEF00000007FFFF;
-    y = 64'h7FFFFFFDFFFFFFEF;
-    z = 64'h41CFFFDFFFFFFFF7;
-    ans = 64'h7FFFFFFDFFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1433075\n");
-    end
-    x = 64'h3FBFFFFF7FFF0000;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1433689\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h3801000200000000;
-    z = 64'hB90000000FDFFFFE;
-    ans = 64'hB8FFFFDE1FBBFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1434303\n");
-    end
-    x = 64'hA33FFFFFFFFF000F;
-    y = 64'h8010000000000000;
-    z = 64'hC02FFFC100000000;
-    ans = 64'hC02FFFC100000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1434917\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h3FDC0378450D3C17;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h3FDC0378450D3C17;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1435531\n");
-    end
-    x = 64'hC3FF00000000001F;
-    y = 64'h37FDA4C8F7C83ED8;
-    z = 64'hC01FC00004000000;
-    ans = 64'hC01FC00004000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1436145\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1436759\n");
-    end
-    x = 64'h7FF164002DF5273F;
-    y = 64'h3FEFFFFE08000000;
-    z = 64'hFFE0000000000000;
-    ans = 64'h7FF964002DF5273F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1437373\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hBCA0000000000000;
-    z = 64'hFFFF87FFFFFFFFFE;
-    ans = 64'hFFFF87FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1437987\n");
-    end
-    x = 64'h400000000001FFEE;
-    y = 64'hC3FFF00000020000;
-    z = 64'h40F00FE000000000;
-    ans = 64'hC40FF0000005FDD4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1438601\n");
-    end
-    x = 64'h41FD4494A975008F;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FEFFFFC576D6AD1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1439215\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hC4E000008000001F;
-    z = 64'h4AA0000000002003;
-    ans = 64'h4AA0000000002003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1439829\n");
-    end
-    x = 64'h40E000040003FFFE;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hBFEFF80007FFFFFE;
-    ans = 64'hBFEFF8000800FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1440443\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hFFFBD39E9E23680E;
-    z = 64'h8010000000000000;
-    ans = 64'hFFFBD39E9E23680E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1441057\n");
-    end
-    x = 64'h0020200001000000;
-    y = 64'hC3F7520A4E692CBB;
-    z = 64'hC3D00000000007FE;
-    ans = 64'hC3D00000000007FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1441671\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h3CA0000000000000;
-    ans = 64'hBFDFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1442285\n");
-    end
-    x = 64'hCE300008000FFFFF;
-    y = 64'h3DFFFFFF800007FF;
-    z = 64'hC340000000000001;
-    ans = 64'hCC400007C00FE3FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1442899\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h800FFFFFFFFC07FF;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1443513\n");
-    end
-    x = 64'hBFDFFFFFFFFEF7FF;
-    y = 64'hC80FFFFAFFFFFFFF;
-    z = 64'h7FE83123594AADF9;
-    ans = 64'h7FE83123594AADF9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1444127\n");
-    end
-    x = 64'h3FBDE21AFA338D84;
-    y = 64'hBFE0000000000001;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FDC43BCA0B98E51;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1444741\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hAA0159203C3AEEA7;
-    z = 64'h43E00007FFFFFFF6;
-    ans = 64'h43E00007FFFFFFF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1445355\n");
-    end
-    x = 64'hBFBCCDD2E538BE7C;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hC7FFFFC000000003;
-    ans = 64'hC7FFFFC000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1445969\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hCA0FFFFFFFFFFFE0;
-    z = 64'h8000000000000001;
-    ans = 64'hCA0FFFFFFFFFFFE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1446583\n");
-    end
-    x = 64'h3EFFFFFFFFFFFF83;
-    y = 64'hC000000000010010;
-    z = 64'hC0300008001FFFFE;
-    ans = 64'hC030000C001FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1447197\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hBFF0000000000001;
-    z = 64'h0010000000000001;
-    ans = 64'hBFF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1447811\n");
-    end
-    x = 64'h43FFFFFFFFEFFFFE;
-    y = 64'hC7EBFFFFFFFFFFF7;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hCBFBFFFFFFF1FFF5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1448425\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h5B8FFFFC00000040;
-    ans = 64'h5B8FFFFC00000040;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1449039\n");
-    end
-    x = 64'h41C00000023FFFFF;
-    y = 64'h402FFF8000003FFF;
-    z = 64'h43EFFFFFF6FFFFFF;
-    ans = 64'h43EFFFFFF73FFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1449653\n");
-    end
-    x = 64'h3CA6A6F59CD6ED19;
-    y = 64'hC000000000000000;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFF9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1450267\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h062F7D4B3A2E44A3;
-    z = 64'h1390007FFFFBFFFF;
-    ans = 64'h1390007FFFFBFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1450881\n");
-    end
-    x = 64'hB5D0000000007FFF;
-    y = 64'hC000000000000001;
-    z = 64'h42800000200000FF;
-    ans = 64'h42800000200000FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1451495\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hC3F0007FFFFFFFEF;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1452109\n");
-    end
-    x = 64'h37FC68F2C9551242;
-    y = 64'hBFE8000000001000;
-    z = 64'hC0FFFFFFF7FC0000;
-    ans = 64'hC0FFFFFFF7FC0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1452723\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hC010000000000000;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1453337\n");
-    end
-    x = 64'h414000007DFFFFFE;
-    y = 64'hBFC00000207FFFFE;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC11000109E8000FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1453951\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hC010000000000001;
-    z = 64'hC1FFFFFFFE000001;
-    ans = 64'hC1FFFFFFFE400001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1454565\n");
-    end
-    x = 64'h42B0007FFFFFFFFF;
-    y = 64'hB7EBFFFF00000000;
-    z = 64'hBFDFFFFFFFFFBFFE;
-    ans = 64'hBFDFFFFFFFFFBFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1455179\n");
-    end
-    x = 64'h802B8498753EDE4C;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1455793\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hBFF0800000000200;
-    z = 64'h3FE0082000000000;
-    ans = 64'hBFE0F7E000000400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1456407\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC340000000000000;
-    z = 64'hBFD000FBFFFFFFFF;
-    ans = 64'hC36FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1457021\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hC3D001FFFFDFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1457635\n");
-    end
-    x = 64'hBCA61E84606C3423;
-    y = 64'h60BFFFFFFFFFFF9E;
-    z = 64'hC3D000007FDFFFFF;
-    ans = 64'hDD761E84606C33DF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1458249\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1458863\n");
-    end
-    x = 64'hC6E007FFFFFFFFFD;
-    y = 64'h41DD22A3BDB366AB;
-    z = 64'hC000000000000000;
-    ans = 64'hC8CD31350F924059;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1459477\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hFFE0000000000000;
-    z = 64'hC02200001FFFFFFE;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1460091\n");
-    end
-    x = 64'hFFE4CA029067CDD2;
-    y = 64'hC3DBFFDFFFFFFFFF;
-    z = 64'h465BFFFFFFF7FFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1460705\n");
-    end
-    x = 64'hBFF0009000000000;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h3CA0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1461319\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hBFCDFFFFFEFFFFFF;
-    z = 64'h262981240D4CABCB;
-    ans = 64'hBFCDFFFFFEFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1461933\n");
-    end
-    x = 64'hB7E0000FFFFFFFEE;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h3FBFFFFFF00003FE;
-    ans = 64'h77E0000FFFFFFFED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1462547\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'h5B30000000081FFF;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1463161\n");
-    end
-    x = 64'hBFE0000000000000;
-    y = 64'h3DBFFFFFFFFFFFFE;
-    z = 64'hBFE7BC400C829841;
-    ans = 64'hBFE7BC400C849841;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1463775\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hFFF0000000000001;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1464389\n");
-    end
-    x = 64'hC014558C41993437;
-    y = 64'h3FFFFFFFFFF80007;
-    z = 64'hBFF0000000000001;
-    ans = 64'hC026558C41941ED9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1465003\n");
-    end
-    x = 64'h3FF0000000000000;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h7FDFFEFF7FFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1465617\n");
-    end
-    x = 64'hFFE000100007FFFF;
-    y = 64'hC1EFFFFFFFFFF9FE;
-    z = 64'h41EFFFFAFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1466231\n");
-    end
-    x = 64'hBFD0002000007FFF;
-    y = 64'h0000000000000001;
-    z = 64'h0010000000000001;
-    ans = 64'h0010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1466845\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h401FFFEFFFFFFE00;
-    z = 64'hB7E0001FFFFFFFF0;
-    ans = 64'h401FFFEFFFFFFE02;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1467459\n");
-    end
-    x = 64'h4030000800000002;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h3FD6420B9320937C;
-    ans = 64'h3FD6420B9320937C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1468073\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hC02FFFFFFF800000;
-    z = 64'h4340000000000001;
-    ans = 64'h433FFFFFFFFFFFF2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1468687\n");
-    end
-    x = 64'hC33D09CE5D5C2E97;
-    y = 64'h37E00000007FFBFF;
-    z = 64'h3FB0000007FFDFFF;
-    ans = 64'h3FB0000007FFDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1469301\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h0010000000000000;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1469915\n");
-    end
-    x = 64'h3CA0003FFFDFFFFF;
-    y = 64'h51B0001FFFFFE000;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'h4E600060005FDFBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1470529\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h41E2741C57480754;
-    ans = 64'h41E2741C57480754;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1471143\n");
-    end
-    x = 64'hC5C0000400000FFE;
-    y = 64'h282FFFEFFFFFBFFF;
-    z = 64'hBE6FFFBFFFFFFFFF;
-    ans = 64'hBE6FFFBFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1471757\n");
-    end
-    x = 64'hC1FFFFFFFFFFFFBB;
-    y = 64'h3CA0000000000000;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hBEAFFFFFFFFFFFBB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1472371\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h43D8225B6AFE04F2;
-    z = 64'h3FDFFE00000007FE;
-    ans = 64'h43D8225B6AFE04F4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1472985\n");
-    end
-    x = 64'hBF9FFFF807FFFFFE;
-    y = 64'h3CA0000000000001;
-    z = 64'hBF90002003FFFFFF;
-    ans = 64'hBF90002004000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1473599\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hC30FFDFFFFFFFDFF;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'hC30FFDFFFFFFFDC1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1474213\n");
-    end
-    x = 64'hBED0001000200000;
-    y = 64'hBFC000000004000E;
-    z = 64'h434FFFFFFFFFFF01;
-    ans = 64'h434FFFFFFFFFFF01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1474827\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1475441\n");
-    end
-    x = 64'h3D0FFE7FFFFFFFFE;
-    y = 64'hBBCE249A24D994EE;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1476055\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h3FD0000000000001;
-    z = 64'h6DBF7BFFFFFFFFFF;
-    ans = 64'h6DBF7BFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1476669\n");
-    end
-    x = 64'h427FF80001FFFFFF;
-    y = 64'hB810FFFFFE000000;
-    z = 64'h4721FBFFFFFFFFFE;
-    ans = 64'h4721FBFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1477283\n");
-    end
-    x = 64'hC3F0000000200800;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1477897\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h403000001FFF0000;
-    z = 64'h381EFFFFFFBFFFFF;
-    ans = 64'h403000001FFF0001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1478511\n");
-    end
-    x = 64'h3EF0004000040000;
-    y = 64'h3FE0000000000000;
-    z = 64'h3FCFFFFFFFEFFFFF;
-    ans = 64'h3FD0002000780008;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1479125\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hBFC000000007FFF7;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400EFFFFFFFF7FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1479739\n");
-    end
-    x = 64'h151288F63CC0F407;
-    y = 64'hC3A078EE7C1CA23C;
-    z = 64'h37E0000400000FFF;
-    ans = 64'h37E0000400000FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1480353\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01BFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1480967\n");
-    end
-    x = 64'h7FF00000F8000000;
-    y = 64'hC3E00FFFFFFFFFFF;
-    z = 64'hBFD0000000000000;
-    ans = 64'h7FF80000F8000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1481581\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h3FF0000000000000;
-    z = 64'hBFFFF7FFF7FFFFFF;
-    ans = 64'hBFEFEFFFEFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1482195\n");
-    end
-    x = 64'h4390001001FFFFFF;
-    y = 64'h41F00000400003FF;
-    z = 64'h73614A879212B060;
-    ans = 64'h73614A879212B060;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1482809\n");
-    end
-    x = 64'h21700040000001FF;
-    y = 64'h3FF0000000000001;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1483423\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h4F41C01D1EBD97EE;
-    z = 64'h4030AF30C9E22201;
-    ans = 64'h4F41C01D1EBD97EF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1484037\n");
-    end
-    x = 64'hB300000000000000;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'hC03FFE003FFFFFFF;
-    ans = 64'hC03FFE003FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1484651\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h081000003FFFFDFF;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1485265\n");
-    end
-    x = 64'h422000040001FFFE;
-    y = 64'hC1D4CBE79C60598B;
-    z = 64'h068EEFFFFFFFFFFE;
-    ans = 64'hC404CBECCF5CDA1D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1485879\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h4000000000000001;
-    z = 64'hC010000000000000;
-    ans = 64'hBFFFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1486493\n");
-    end
-    x = 64'h0020000000BFFFFF;
-    y = 64'hC008D81E79C4BDF1;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1487107\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hC80C000000003FFF;
-    ans = 64'hC80C000000003FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1487721\n");
-    end
-    x = 64'h402000001FFFFFFB;
-    y = 64'hBFD00003FFDFFFFF;
-    z = 64'hBFFFFFFC00000010;
-    ans = 64'hC01000010FF00401;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1488335\n");
-    end
-    x = 64'h3F9FFFFFC00FFFFF;
-    y = 64'h4010000000000000;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1488949\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h12E0002000000000;
-    z = 64'h438FBFFFFFFEFFFF;
-    ans = 64'h438FBFFFFFFEFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1489563\n");
-    end
-    x = 64'h434FF80001FFFFFF;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h2FEFFFFBF7FFFFFF;
-    ans = 64'h437FF80001FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1490177\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h93120000003FFFFF;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1490791\n");
-    end
-    x = 64'hB7EFFFFFFFFFFFF1;
-    y = 64'hC1C946962E1C5437;
-    z = 64'hB3BF8000007FFFFF;
-    ans = 64'h39C946962E1C542B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1491405\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h4340000000000000;
-    z = 64'hC000000000000001;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1492019\n");
-    end
-    x = 64'hC05FFFFFFE0001FE;
-    y = 64'hC033FB5821777B64;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h40A3FB582037C720;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1492633\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hFFDFFFFFA0000000;
-    ans = 64'hFFDFFFFFA0000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1493247\n");
-    end
-    x = 64'hBFE0000082000000;
-    y = 64'h3F00000000000010;
-    z = 64'h3FEE3E1841C696F0;
-    ans = 64'h3FEE3DF841C592F0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1493861\n");
-    end
-    x = 64'hBFE0000100FFFFFF;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC3580000807FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1494475\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hC0096863BF8D68B1;
-    z = 64'h8D53FFFFFFFF7FFF;
-    ans = 64'hC0096863BF8D68B3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1495089\n");
-    end
-    x = 64'h4130FFFFFFFFFFF8;
-    y = 64'h7FE0000000000001;
-    z = 64'h400757A0F4028052;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1495703\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hFFE598A2EFE0CC56;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'hFFE598A2EFE0CC57;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1496317\n");
-    end
-    x = 64'hBF8FFFFF0000FFFF;
-    y = 64'hCAAFFFFFFFFDEFFE;
-    z = 64'hBFB6E9A88034930A;
-    ans = 64'h4A4FFFFEFFFEEFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1496931\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1497545\n");
-    end
-    x = 64'h43D0000000087FFF;
-    y = 64'hD7B36A7D8CEAEBE7;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hDB936A7D8CF53C78;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1498159\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h7FF0000000000001;
-    z = 64'hBCA0007FFFFFFFEF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1498773\n");
-    end
-    x = 64'hC03FFF000000000F;
-    y = 64'h403FFFF8000003FF;
-    z = 64'h37F00800003FFFFF;
-    ans = 64'hC08FFEF80040040E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1499387\n");
-    end
-    x = 64'h4030000000FFBFFF;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1500001\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h403FFFF0000000FF;
-    z = 64'hD4F00013FFFFFFFF;
-    ans = 64'hD4F00013FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1500615\n");
-    end
-    x = 64'hC6DA302F95D53E41;
-    y = 64'h8000000000000000;
-    z = 64'h3A8FF7FFFE000000;
-    ans = 64'h3A8FF7FFFE000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1501229\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hBCA7FFFFFEFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1501843\n");
-    end
-    x = 64'h3FBFFFFFFDFF7FFE;
-    y = 64'hC7EFFFFE00020000;
-    z = 64'h43AFFFFF8003FFFE;
-    ans = 64'hC7BFFFFDFE01801E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1502457\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1503071\n");
-    end
-    x = 64'h0003476357EBF517;
-    y = 64'h7FE000004000003F;
-    z = 64'h8000000000000000;
-    ans = 64'h3FDA3B1B284C141D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1503685\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h8010000000000000;
-    z = 64'hFFF71E22014210B7;
-    ans = 64'hFFFF1E22014210B7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1504299\n");
-    end
-    x = 64'hB7F00000FFFFFFBF;
-    y = 64'hB81E94EC16510659;
-    z = 64'hE5900000000000FC;
-    ans = 64'hE5900000000000FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1504913\n");
-    end
-    x = 64'h255FC00010000000;
-    y = 64'h8010000000000001;
-    z = 64'hC010000000000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1505527\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hC7E00000FFFFDFFF;
-    z = 64'hBFCDFFFC00000000;
-    ans = 64'hC7E00000FFFFE000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1506141\n");
-    end
-    x = 64'h381FEFFDFFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hFFF0207FFFFFFFFF;
-    ans = 64'hFFF8207FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1506755\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h406333A1C67874F2;
-    z = 64'h3FD0000000000000;
-    ans = 64'h40633BA1C67874F3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1507369\n");
-    end
-    x = 64'h3F8000003FFBFFFF;
-    y = 64'hB3FFF8003FFFFFFF;
-    z = 64'h3CA5CDFC371469D5;
-    ans = 64'h3CA5CDFC371469D5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1507983\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hBCA0000000000001;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1508597\n");
-    end
-    x = 64'hC011000400000000;
-    y = 64'hC1FEEDF467BB14D3;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1509211\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hB9706068EB130215;
-    ans = 64'hBCB0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1509825\n");
-    end
-    x = 64'h340FFFFFFFFFFFDC;
-    y = 64'hC3D8682AE89D9DE3;
-    z = 64'hB80FFE0000010000;
-    ans = 64'hB816190ABA27E772;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1510439\n");
-    end
-    x = 64'h3BAFFFFFFFFFFF02;
-    y = 64'hBFD0000000000000;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1511053\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h002FF80008000000;
-    z = 64'h42EFEFFFFFEFFFFF;
-    ans = 64'h42EFEFFFFFEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1511667\n");
-    end
-    x = 64'h388FFF7FFFFFDFFF;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h63CFFFEBFFFFFFFF;
-    ans = 64'h63CFFFEBFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1512281\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h480008000000000F;
-    z = 64'h3CA0000000000001;
-    ans = 64'h4800080000000010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1512895\n");
-    end
-    x = 64'hC04000001001FFFE;
-    y = 64'h3FD00E1A7AB10717;
-    z = 64'hBE9CEA205823E383;
-    ans = 64'hC0200E1A9936337F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1513509\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hBFE0000000000000;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFE8000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1514123\n");
-    end
-    x = 64'h3E8FFFFF7FFFFDFF;
-    y = 64'hB80FFFFEFFFBFFFE;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1514737\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h7FD0001FFFFFC000;
-    ans = 64'h7FD0001FFFFFC000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1515351\n");
-    end
-    x = 64'h43DFFFFFFFFFBFEF;
-    y = 64'hC0100000BFFFFFFF;
-    z = 64'hBCA00FFF7FFFFFFF;
-    ans = 64'hC4000000BFFFDFF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1515965\n");
-    end
-    x = 64'h3DBF001FFFFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hC00000000000F800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1516579\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hBFCFF7FFFDFFFFFF;
-    z = 64'hBFE000000007FFFB;
-    ans = 64'hBFE7FDFFFF87FFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1517193\n");
-    end
-    x = 64'h43E0001000001000;
-    y = 64'hBFF0000000000001;
-    z = 64'hC0F092135375188F;
-    ans = 64'hC3E0001000001022;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1517807\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hB81F7FFFFFFFFFBE;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'hB81F7FFFFFFFFFC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1518421\n");
-    end
-    x = 64'hBF20000000003FEF;
-    y = 64'hA550A89F56EB2FAD;
-    z = 64'hC00003FFF7FFFFFF;
-    ans = 64'hC00003FFF7FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1519035\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1519649\n");
-    end
-    x = 64'h3FDFBFFFFFFFFDFF;
-    y = 64'hBFC0000000005FFE;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1520263\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hC000000000000001;
-    z = 64'h41BFFFE001FFFFFF;
-    ans = 64'h41BFFFDFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1520877\n");
-    end
-    x = 64'hC3FFC003FFFFFFFF;
-    y = 64'h802F6AF6024C08B5;
-    z = 64'h3FEFFFFFF80FFFFE;
-    ans = 64'h3FEFFFFFF80FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1521491\n");
-    end
-    x = 64'h4770000000017FFE;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hC790000000017FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1522105\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hBFD40001FFFFFFFE;
-    z = 64'hC04007FFFFFFFBFF;
-    ans = 64'hC040300003FFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1522719\n");
-    end
-    x = 64'h41D566DE1FA9698E;
-    y = 64'hC010000000000000;
-    z = 64'h3FC01FFFFFFDFFFE;
-    ans = 64'hC1F566DE1FA7658E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1523333\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h47F4831548A0898D;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h47F4831548A0898E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1523947\n");
-    end
-    x = 64'h434000000021FFFF;
-    y = 64'hC1CFFFFFFFFF7FF7;
-    z = 64'h37F0080080000000;
-    ans = 64'hC52000000021BFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1524561\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'hC020000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1525175\n");
-    end
-    x = 64'h7E6FFFF80000007F;
-    y = 64'h37E0008FFFFFFFFE;
-    z = 64'h4340000000000000;
-    ans = 64'h7660008BFFDC003E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1525789\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hC340000000000000;
-    z = 64'hC770000000023FFF;
-    ans = 64'hC770000000023FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1526403\n");
-    end
-    x = 64'hE9500000001FFFFF;
-    y = 64'hC00BFFFFF7FFFFFF;
-    z = 64'h2EDBFFFFFFFC0000;
-    ans = 64'h696BFFFFF837FFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1527017\n");
-    end
-    x = 64'h47F000003FFFFFE0;
-    y = 64'hC340000000000001;
-    z = 64'hBFE0000000000000;
-    ans = 64'hCB4000003FFFFFE1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1527631\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hAA790F9E140279B6;
-    z = 64'h3FE08000000FFFFF;
-    ans = 64'h3FE08000000FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1528245\n");
-    end
-    x = 64'hC0A007FFFEFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hB810000004000003;
-    ans = 64'h440007FFFEFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1528859\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h3FC7F50DD5148BA7;
-    z = 64'h0000000000000000;
-    ans = 64'h3FC7F50DD5148BA8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1529473\n");
-    end
-    x = 64'h4698040000000000;
-    y = 64'h37FFEFFFFFFFBFFF;
-    z = 64'h200000FBFFFFFFFF;
-    ans = 64'h3EA7F7FDFFFFCFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1530087\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hFFE0000000000001;
-    z = 64'h8010000000000000;
-    ans = 64'hFFE0000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1530701\n");
-    end
-    x = 64'h790000100000001F;
-    y = 64'hC2D58B4193E58B37;
-    z = 64'h4010000000000001;
-    ans = 64'hFBE58B571F271F46;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1531315\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h40769FBEEA3D4736;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1531929\n");
-    end
-    x = 64'hC3E0007FFFFFFFFF;
-    y = 64'hC0000000000207FF;
-    z = 64'hFFD000000001EFFF;
-    ans = 64'hFFD000000001EFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1532543\n");
-    end
-    x = 64'h3FD3EEE5BED7AEF6;
-    y = 64'hFFF0000000000000;
-    z = 64'hBFD0000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1533157\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'h43EF800400000000;
-    z = 64'hC02FFFFFFFFFFF40;
-    ans = 64'h43EF800400000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1533771\n");
-    end
-    x = 64'hAF94000000003FFF;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h37F000001EFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1534385\n");
-    end
-    x = 64'h3FF0000000000001;
-    y = 64'hB9FF00000003FFFF;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1534999\n");
-    end
-    x = 64'hC34439AD7B57B86A;
-    y = 64'h41CFFFFFFFF807FE;
-    z = 64'h429FFDFFFFFFF000;
-    ans = 64'hC52439AD7B529F0D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1535613\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h0000000000000000;
-    z = 64'h8000000000000001;
-    ans = 64'h8000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1536227\n");
-    end
-    x = 64'hC02BBD44DD056675;
-    y = 64'hC1C000000005FFFF;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h41FBBD44DD4FCD6D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1536841\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h3FBFFFE001FFFFFF;
-    ans = 64'h3FBFFFE001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1537455\n");
-    end
-    x = 64'h3CAFFFFFFF83FFFF;
-    y = 64'h37E00003FFFFFFDE;
-    z = 64'h40200000003FFFF7;
-    ans = 64'h40200000003FFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1538069\n");
-    end
-    x = 64'h3F1000047FFFFFFE;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1538683\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h43F2459EC8CC5AA8;
-    z = 64'hBFBC00D7CE203DB4;
-    ans = 64'h4402459EC8CC5AA7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1539297\n");
-    end
-    x = 64'h380FFFFFFF7FF7FE;
-    y = 64'h0010000000000001;
-    z = 64'hFFEFFFFFFFFFF80F;
-    ans = 64'hFFEFFFFFFFFFF80F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1539911\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h43C010001FFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1540525\n");
-    end
-    x = 64'h41D00FFFFFFFFFFB;
-    y = 64'hA8FC400000000000;
-    z = 64'h4051000000001FFF;
-    ans = 64'h4051000000001FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1541139\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1541753\n");
-    end
-    x = 64'h454000000000FF7E;
-    y = 64'hC3CFFFFDFFFFFF80;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'hC91FFFFE0001FE7C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1542367\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h3CA0000000000001;
-    z = 64'h98800000400000FF;
-    ans = 64'h3CB0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1542981\n");
-    end
-    x = 64'hD90077FFFFFFFFFF;
-    y = 64'h41CFFFFFFFFFFFFF;
-    z = 64'h3FEFFFFFFFFF7FFD;
-    ans = 64'hDAE077FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1543595\n");
-    end
-    x = 64'h37FFFFFC000007FF;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h34BFFFFC000007FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1544209\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hFFAFFFFFFFBFFDFE;
-    z = 64'h3FE2863660754A51;
-    ans = 64'hFFBFFFFFFFBFFDFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1544823\n");
-    end
-    x = 64'hB8100000FFFFFDFE;
-    y = 64'h3FD0000000000000;
-    z = 64'h41C0000800000000;
-    ans = 64'h41C0000800000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1545437\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h366FFFFE00400000;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1546051\n");
-    end
-    x = 64'hA18FDD1E4F1D8794;
-    y = 64'hE5FE3FFFFFFFFFFF;
-    z = 64'hC1EC6D016FC1B191;
-    ans = 64'h479E1F06A6C9EA29;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1546665\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1547279\n");
-    end
-    x = 64'h3FCFFFF1FFFFFFFF;
-    y = 64'hB8000001FF7FFFFF;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1547893\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h3FE0000000000000;
-    z = 64'h0011BC66A6AFD091;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1548507\n");
-    end
-    x = 64'h68A5BD6C73D63CB8;
-    y = 64'h43D1FFF7FFFFFFFF;
-    z = 64'h3C40008000FFFFFF;
-    ans = 64'h6C88750F239ACA63;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1549121\n");
-    end
-    x = 64'h3CAFFFFFC0000003;
-    y = 64'h3FE0000000000001;
-    z = 64'h8010000000000000;
-    ans = 64'h3C9FFFFFC0000005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1549735\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h3F6000023FFFFFFE;
-    z = 64'h7FF00001FFFEFFFE;
-    ans = 64'h7FF80001FFFEFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1550349\n");
-    end
-    x = 64'hBF000000007FE000;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hBFDFFFFFF5FFFFFF;
-    ans = 64'hBFE0003FFB0001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1550963\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hB361F0FC60A5C255;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1551577\n");
-    end
-    x = 64'hC0300000002FFFFE;
-    y = 64'h395FFFEFFFFFFFFF;
-    z = 64'hB95FFFEFFFF7FFFF;
-    ans = 64'hB9A0FFF7802FBFE5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1552191\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h3FF0000000000001;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1552805\n");
-    end
-    x = 64'hA140000000FFFFBE;
-    y = 64'h40BFFFFF00000007;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1553419\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h496131E708AD247B;
-    ans = 64'h496131E708AD247B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1554033\n");
-    end
-    x = 64'h40233C8AC990330C;
-    y = 64'h3E6000000003DFFF;
-    z = 64'h3FD0007FF7FFFFFF;
-    ans = 64'h3FD000812BC8AC98;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1554647\n");
-    end
-    x = 64'hBDD00000000FFFDF;
-    y = 64'h4000000000000000;
-    z = 64'h8000000000000001;
-    ans = 64'hBDE00000000FFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1555261\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h7FEB41A3838A8AC9;
-    z = 64'hCBDFFFFFFFD7FFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1555875\n");
-    end
-    x = 64'hBE8C8E5F27717F72;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h409000000000FFFC;
-    ans = 64'h408FFFFFFF8FC67B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1556489\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h3F3FFFFFFEFFFFFF;
-    z = 64'hC010000000000001;
-    ans = 64'hC00FFE0000001002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1557103\n");
-    end
-    x = 64'h7FF8F9996F21B694;
-    y = 64'hB14FFFFFFFFC001F;
-    z = 64'hD36000000BFFFFFF;
-    ans = 64'h7FF8F9996F21B694;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1557717\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h4010000000000000;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1558331\n");
-    end
-    x = 64'hFFDFFFE01FFFFFFE;
-    y = 64'h400FFFF3FFFFFFFF;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1558945\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h4010000000000001;
-    z = 64'hC1D3347EDAE48B72;
-    ans = 64'hC1D3347ED8E48B72;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1559559\n");
-    end
-    x = 64'h000ACDCC076E0ADF;
-    y = 64'h3D6666AA8E1AABE5;
-    z = 64'h403BFFFFFFF7FFFF;
-    ans = 64'h403BFFFFFFF7FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1560173\n");
-    end
-    x = 64'h381000000FFF0000;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1560787\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h3CAF800001FFFFFE;
-    z = 64'h3800000002100000;
-    ans = 64'h3CBF800001FFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1561401\n");
-    end
-    x = 64'hC3EFFFFFDFFFFFFA;
-    y = 64'h4340000000000001;
-    z = 64'hC680063611833898;
-    ans = 64'hC740010053611832;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1562015\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hAE79CAC1FE3DF21C;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1562629\n");
-    end
-    x = 64'h35200007FFFFE000;
-    y = 64'hBFBFFFFFFDEFFFFF;
-    z = 64'hBFF6AC5CC5343BAF;
-    ans = 64'hBFF6AC5CC5343BAF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1563243\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h435FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1563857\n");
-    end
-    x = 64'h3FC00FFFFFFFFF7E;
-    y = 64'hB80000000080003F;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1564471\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h7FE0000000000000;
-    z = 64'h9520000001FFFBFE;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1565085\n");
-    end
-    x = 64'h3F2BFFFFFFFFFFFD;
-    y = 64'h80200FFFFFBFFFFE;
-    z = 64'hC1F0000003FBFFFE;
-    ans = 64'hC1F0000003FBFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1565699\n");
-    end
-    x = 64'hEA600000001000FF;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1566313\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hC3FFFFFFFFFFF801;
-    z = 64'hFFF00000FFDFFFFE;
-    ans = 64'hFFF80000FFDFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1566927\n");
-    end
-    x = 64'h37DFE000003FFFFF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hC04FFFFFFFFFB7FE;
-    ans = 64'h77DFE000003FFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1567541\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h400FFFE200000000;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'h4017FFE200000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1568155\n");
-    end
-    x = 64'hBFCFFFFFFFFFF810;
-    y = 64'h3FF0000003FFBFFF;
-    z = 64'h41EFF8007FFFFFFF;
-    ans = 64'h41EFF8007FF7FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1568769\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1569383\n");
-    end
-    x = 64'hBC3FFFFFFFFFFC01;
-    y = 64'hBFD0484EBF02F052;
-    z = 64'h3CA0000000000000;
-    ans = 64'h3CA010484EBF02EE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1569997\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h00000007FFC00000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1570611\n");
-    end
-    x = 64'h43FFFFFFFFFFC001;
-    y = 64'h47FFB25D4AD4E4DB;
-    z = 64'h3FF0080000000000;
-    ans = 64'h4C0FB25D4AD4A577;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1571225\n");
-    end
-    x = 64'h402F81736BA4D5A0;
-    y = 64'h8000000000000001;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1571839\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h3FB4004000000000;
-    z = 64'h41631A545858549B;
-    ans = 64'h41631A545D58649B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1572453\n");
-    end
-    x = 64'h41F7FFFFFFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h41C1C06162ADBF79;
-    ans = 64'h41C1C06162ADBF79;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1573067\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h3FC00FFFFFFFFE00;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFE7F80000000100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1573681\n");
-    end
-    x = 64'h000FFFFFFFFF8004;
-    y = 64'hBFCFFF8000000001;
-    z = 64'h3FF00000000004FF;
-    ans = 64'h3FF00000000004FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1574295\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h8010000000000001;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1574909\n");
-    end
-    x = 64'h411FFFC000100000;
-    y = 64'hBC40004FFFFFFFFE;
-    z = 64'h0010000000000001;
-    ans = 64'hBD70002FFF680026;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1575523\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h3BE292DF5A68281D;
-    ans = 64'h3BE292DF5A68281D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1576137\n");
-    end
-    x = 64'h3F60401000000000;
-    y = 64'h294000020000000F;
-    z = 64'h80000407FFFFFFFE;
-    ans = 64'h28B040120802000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1576751\n");
-    end
-    x = 64'h4801FFFFFFFFFFFE;
-    y = 64'hBCA0000000000000;
-    z = 64'h4340000000000001;
-    ans = 64'hC4B1FFFFDFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1577365\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hC7E000001001FFFF;
-    z = 64'h309FFFFFFFBFFFF0;
-    ans = 64'hC7F000001001FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1577979\n");
-    end
-    x = 64'hBE203FFFFFF00000;
-    y = 64'hBCA0000000000001;
-    z = 64'hC030000000003EFF;
-    ans = 64'hC030000000003EFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1578593\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hC1D0000040FFFFFE;
-    z = 64'hBFE0000000000001;
-    ans = 64'hC1E00000410FFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1579207\n");
-    end
-    x = 64'h3A50400000080000;
-    y = 64'hC7EFFFFF6FFFFFFF;
-    z = 64'hA51FFFFFFFFF7000;
-    ans = 64'hC2503FFFB6E7FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1579821\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hBFD0000000000000;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FE0000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1580435\n");
-    end
-    x = 64'h8000408000000000;
-    y = 64'hB7F00001FFFFFE00;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h000FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1581049\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hBFD0000000000001;
-    z = 64'hC02000000080007E;
-    ans = 64'hC02100000080007E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1581663\n");
-    end
-    x = 64'h3280000780000000;
-    y = 64'h7FD007DFFFFFFFFF;
-    z = 64'h4C8FFFEFDFFFFFFF;
-    ans = 64'h726007E783B0FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1582277\n");
-    end
-    x = 64'hBEAFFFFFFFFFF007;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h402000000FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1582891\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h42DFFDFFFFFFFFFF;
-    z = 64'h3F4FFFFF3FFFFFFF;
-    ans = 64'h42EFFDFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1583505\n");
-    end
-    x = 64'hBFBE000003FFFFFF;
-    y = 64'hBFE0000000000000;
-    z = 64'hAC9FEFFFFFFFFEFF;
-    ans = 64'h3FAE000003FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1584119\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hC1D0000008000400;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hC1E00000081003FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1584733\n");
-    end
-    x = 64'hD2B1000000007FFF;
-    y = 64'hCA8186CC19B70C07;
-    z = 64'hC00EB7E6E75515EB;
-    ans = 64'h5D429F38DB5308FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1585347\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1585961\n");
-    end
-    x = 64'hC0300BFFFFFFFFFE;
-    y = 64'h744003FFFFFFFFFC;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1586575\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hBFF0000000000000;
-    z = 64'hB7F06F51947E5EFA;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1587189\n");
-    end
-    x = 64'hBCAFFFFFFDFEFFFF;
-    y = 64'hDBDFFFFFFFF5FFFE;
-    z = 64'h45465A4CBC45F897;
-    ans = 64'h589FFFFFFDF4FFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1587803\n");
-    end
-    x = 64'h4080000000007DFE;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'hC08FE0000000FBFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1588417\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h3FD02003FFFFFFFF;
-    z = 64'hB80E4FB403E45282;
-    ans = 64'h3FE02003FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1589031\n");
-    end
-    x = 64'h4DC0007FFFFFBFFF;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h7FF1C24919B8C488;
-    ans = 64'h7FF9C24919B8C488;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1589645\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hC06FFBFFFFFFFFDF;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hC07FFBFFFFFFFFDE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1590259\n");
-    end
-    x = 64'h0C30001000001FFF;
-    y = 64'h3FDFFFFFFFFBFFFD;
-    z = 64'hC3E2000000003FFF;
-    ans = 64'hC3E2000000003FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1590873\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'hC01DFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1591487\n");
-    end
-    x = 64'h39A00000FFFFFFF7;
-    y = 64'hC0200000FFFFFFFF;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1592101\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hC2AA4072EAF00758;
-    ans = 64'hC2AA4072EAF01758;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1592715\n");
-    end
-    x = 64'h37FD755CDABEA76D;
-    y = 64'h3C5FFFDBFFFFFFFF;
-    z = 64'hBFE0000000007FF8;
-    ans = 64'hBFE0000000007FF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1593329\n");
-    end
-    x = 64'h801197F207B69AE6;
-    y = 64'hC010000000000001;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1593943\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h41EF00000000001F;
-    z = 64'h315FFFFFFFFFFFC0;
-    ans = 64'h41FF00000000001E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1594557\n");
-    end
-    x = 64'hABBFFBFFFFFF0000;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hC1F748C9C20C8D0E;
-    ans = 64'hC1F748C9C20C8D0E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1595171\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h480FFFFFFFFFC07F;
-    z = 64'hBCA0000000000000;
-    ans = 64'h481FFFFFFFFFC07E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1595785\n");
-    end
-    x = 64'h3FF0000000007FDF;
-    y = 64'h6E3FFFFFDFFFFFDF;
-    z = 64'h7FF1FEFFFFFFFFFF;
-    ans = 64'h7FF9FEFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1596399\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hC340000000000001;
-    z = 64'h3FD0000000000000;
-    ans = 64'hC350000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1597013\n");
-    end
-    x = 64'hB800005FFFFFFFFF;
-    y = 64'hC18FFFFFFE0007FE;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1597627\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h3FE8DD2068625FC3;
-    ans = 64'hC35FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1598241\n");
-    end
-    x = 64'hC035303BE73A8A2A;
-    y = 64'hB7FFFFFFDFFFBFFF;
-    z = 64'h43A6B1CE510FDDF7;
-    ans = 64'h43A6B1CE510FDDF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1598855\n");
-    end
-    x = 64'hB21FFFFE0001FFFE;
-    y = 64'hFFE0000000000000;
-    z = 64'h3FF0000000000001;
-    ans = 64'h720FFFFE0001FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1599469\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hBFF00000000BFFFF;
-    z = 64'hBE90000000203FFE;
-    ans = 64'hC0000000200BFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1600083\n");
-    end
-    x = 64'h43F0000EFFFFFFFF;
-    y = 64'hFFE0000000000001;
-    z = 64'h00218A882612E878;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1600697\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'h3F90000000083FFF;
-    z = 64'h8010000000000001;
-    ans = 64'h3FA0000000083FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1601311\n");
-    end
-    x = 64'h49EE00FFFFFFFFFE;
-    y = 64'h60BFFFF7FFF00000;
-    z = 64'h401FFE0000000002;
-    ans = 64'h6ABE00F87FB0FF7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1601925\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hFFF0000000000000;
-    z = 64'h3CA0000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1602539\n");
-    end
-    x = 64'h3FF0001FFFFFFFFF;
-    y = 64'h37F1095A919815A3;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1603153\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hFFF0000000000001;
-    z = 64'hD282D5D3556E116C;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1603767\n");
-    end
-    x = 64'h802FFFFFFFF001FF;
-    y = 64'h3F4FBFFFFFFFFFDF;
-    z = 64'hB81BE0B691B01D79;
-    ans = 64'hB81BE0B691B01D79;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1604381\n");
-    end
-    x = 64'h41D0040000000000;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1604995\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFF;
-    y = 64'hBC8FFF7FFFFFFFFF;
-    z = 64'h802C00000000007E;
-    ans = 64'hBC9FFF7FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1605609\n");
-    end
-    x = 64'hB71A7857DD67746E;
-    y = 64'h0000000000000000;
-    z = 64'h380007F7FFFFFFFF;
-    ans = 64'h380007F7FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1606223\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h40541CECECF3BC00;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h40641CECECF3BBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1606837\n");
-    end
-    x = 64'h0DFFFFFF00000008;
-    y = 64'hC7E000000008001F;
-    z = 64'h7FF6A62452074BC7;
-    ans = 64'h7FFEA62452074BC7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1607451\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h002FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1608065\n");
-    end
-    x = 64'h800FFFF7FFFFBFFF;
-    y = 64'h407335261EC0BFB2;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1608679\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h0010000000000000;
-    z = 64'hD0B01FFFFFFFBFFF;
-    ans = 64'hD0B01FFFFFFFBFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1609293\n");
-    end
-    x = 64'hBFDFFFC000000004;
-    y = 64'hC00000000003FFBF;
-    z = 64'hC53BFBFFFFFFFFFE;
-    ans = 64'hC53BFBFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1609907\n");
-    end
-    x = 64'h43C483F6E8D46B6A;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1610521\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hC3EFFFFE01FFFFFE;
-    z = 64'h40F73755595D1E7C;
-    ans = 64'hC3FFFFFE01FFFFE5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1611135\n");
-    end
-    x = 64'h410FFFFF8000001E;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hC1FD1E0EB5DF203D;
-    ans = 64'hC1FD1E0EB5DF203D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1611749\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hFFD53A3B1BD0418E;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1612363\n");
-    end
-    x = 64'hC00FFFEFFFFFF7FE;
-    y = 64'hC3CFE001FFFFFFFE;
-    z = 64'h41C00003FFFFFF7F;
-    ans = 64'h43EFDFF21002F805;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1612977\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h3CBFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1613591\n");
-    end
-    x = 64'h3FC0400040000000;
-    y = 64'hC0200000004001FE;
-    z = 64'hC010000000000000;
-    ans = 64'hC014100010104082;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1614205\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h47EEC35A3E8C408E;
-    ans = 64'h47EEC35A3E8C408E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1614819\n");
-    end
-    x = 64'hB7CFFFFDFFFFFFBE;
-    y = 64'hE79FFFFFFBFFFF7E;
-    z = 64'hB7FFFFE000000400;
-    ans = 64'h5F7FFFFDFBFFFF7C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1615433\n");
-    end
-    x = 64'h3D5DFFFE00000000;
-    y = 64'h3FD0000000000001;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000780;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1616047\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hC12FFEFFFFFFFFFE;
-    z = 64'hBFDC4312AA3B4103;
-    ans = 64'hC13FFF00710C4AA5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1616661\n");
-    end
-    x = 64'h4020000000000207;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h3CB10000000003FE;
-    ans = 64'h4010000000000207;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1617275\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hB7E00000000007BF;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1617889\n");
-    end
-    x = 64'h43CFFFFEFFFFFE00;
-    y = 64'hC3E1DFFFFFFFFFFE;
-    z = 64'hC3DFDB4465B607F2;
-    ans = 64'hC7C1DFFF70FFFEE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1618503\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h3FE0000000000001;
-    z = 64'h0000000000000000;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1619117\n");
-    end
-    x = 64'h43401FFFFFFFFFBF;
-    y = 64'hBFCFFBFFFFFFFE00;
-    z = 64'hC000000000000001;
-    ans = 64'hC3201DFBFFFFFEC1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1619731\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h41D0B0544FEB5078;
-    ans = 64'h41D0B054506B5078;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1620345\n");
-    end
-    x = 64'h434FFFFFFFF8FFFF;
-    y = 64'h400FFFFC07FFFFFE;
-    z = 64'hC3D07FFFFBFFFFFF;
-    ans = 64'hC3D0400003F00DFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1620959\n");
-    end
-    x = 64'hB7F0003FFFFFFFBF;
-    y = 64'h3FF0000000000000;
-    z = 64'h3CA0000000000001;
+    ReadData1E = 64'h380FFFFBFFFFFFFF;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'h3CA0000000000001;
     ans = 64'h3CA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1621573\n");
+    	$fwrite(fp,"1037033\n");
     end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h401FFFFFFFBFEFFF;
-    z = 64'hBFBFFFFFFBFFFBFF;
-    ans = 64'h402FBFFFFFC7F005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h801DFFFFFFFDFFFF;
+    ReadData2E = 64'hC0800001FFFFFFC0;
+    ReadData3E = 64'hBFD00101FFFFFFFE;
+    ans = 64'hBFD00101FFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1622187\n");
+    	$fwrite(fp,"1037339\n");
     end
-    x = 64'h3FD7C889A9DD25D9;
-    y = 64'h3FF0000000000001;
-    z = 64'hB7EFFF0001FFFFFE;
-    ans = 64'h3FD7C889A9DD25DA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'hCA404000000007FE;
+    ans = 64'hCA404000000007FE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1622801\n");
+    	$fwrite(fp,"1037645\n");
     end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h37E38E855844BDB2;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1623415\n");
-    end
-    x = 64'h3FBFFFFFFFFF8800;
-    y = 64'h404FFFFFBC000000;
-    z = 64'hC31FF80003FFFFFF;
-    ans = 64'hC31FF80003FFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1624029\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1624643\n");
-    end
-    x = 64'hC3B00000FFFF7FFF;
-    y = 64'h0010000009FFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1625257\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h4000000000000001;
-    z = 64'hB80B4B5C90860317;
-    ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1625871\n");
-    end
-    x = 64'h000C37F7A56E5695;
-    y = 64'h2A72123EDDA1B8F9;
-    z = 64'hB910080000040000;
-    ans = 64'hB910080000040000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1626485\n");
-    end
-    x = 64'h434FFFFFFD000000;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h436FFFFFFCFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1627099\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h405FC00004000000;
-    z = 64'hC1E0000001FFFFFC;
-    ans = 64'hC1DFFFFFC47FFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1627713\n");
-    end
-    x = 64'hC1EFC00000004000;
-    y = 64'h4010000000000000;
-    z = 64'hCFC858BF316FDD04;
-    ans = 64'hCFC858BF316FDD04;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1628327\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h41EFFFFFFC3FFFFE;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h435000007FFFFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1628941\n");
-    end
-    x = 64'hC5002000000001FE;
-    y = 64'h002FFFFF0000001E;
-    z = 64'hBF20800000000000;
-    ans = 64'hBF20800000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1629555\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1630169\n");
-    end
-    x = 64'h0010000000020800;
-    y = 64'hBFC13358D21972CF;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1630783\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h4340000000000000;
-    z = 64'h41D007FFFFFFF800;
-    ans = 64'h435000001007FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1631397\n");
-    end
-    x = 64'h4760000020003FFF;
-    y = 64'hED03F987D1321ACA;
-    z = 64'h4940000001008000;
-    ans = 64'hF473F987F9257A51;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1632011\n");
-    end
-    x = 64'hC3CFFDFFFFFFFF7F;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'hC72FFDFFFFFFFF7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1632625\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hC7F001FFFFEFFFFF;
-    z = 64'hC1D0000000200FFF;
-    ans = 64'hC80001FFFFEFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1633239\n");
-    end
-    x = 64'hC3FEDDFD05C7A4CA;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h401FFFFDF7FFFFFF;
-    ans = 64'hC75EDDFD05C7A4C8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1633853\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h8020007FFFFFBFFE;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1634467\n");
-    end
-    x = 64'h4000002003FFFFFE;
-    y = 64'hBC4FFFFFBFFFFFFE;
-    z = 64'hBFBFFFFFFFFFE3FF;
-    ans = 64'hBFBFFFFFFFFFE400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1635081\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h7FE0000000000001;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1635695\n");
-    end
-    x = 64'hC6500004FFFFFFFE;
-    y = 64'h41DFFFC000008000;
-    z = 64'hBFE0000000000000;
-    ans = 64'hC83FFFC9FFEC7FFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1636309\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h7FFFFFFE000007FE;
-    ans = 64'h7FFFFFFE000007FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1636923\n");
-    end
-    x = 64'h3FD0000000500000;
-    y = 64'h41C000001FFFDFFF;
-    z = 64'h40102011D91D9285;
-    ans = 64'h41A00000285FE8EC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1637537\n");
-    end
-    x = 64'h43E000200FFFFFFF;
-    y = 64'h7FF0000000000001;
-    z = 64'h0000000000000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1638151\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h3596637D20B04D3A;
-    z = 64'hBF8106C2B0B30F67;
-    ans = 64'hBF8106C2B0B30F67;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1638765\n");
-    end
-    x = 64'hBFF0000400007FFF;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h402FFFF000007FFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1639379\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h3CA351FEA32C59ED;
-    z = 64'h4010000000000000;
-    ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1639993\n");
-    end
-    x = 64'hC03F7FFFFFFFFFE0;
-    y = 64'hC600000040400000;
-    z = 64'h9B87FF7FFFFFFFFF;
-    ans = 64'h464F80007E7DFFE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1640607\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h8000000000000000;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1641221\n");
-    end
-    x = 64'h3DE0002000000080;
-    y = 64'hBFE9F6F80CF16503;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFD000000019F72D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1641835\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hC7F00000000005FE;
-    ans = 64'hC7F00000000005FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1642449\n");
-    end
-    x = 64'hC00DFFF800000000;
-    y = 64'h401FDFFFFFFFFFFF;
-    z = 64'hC34B14F95370BE13;
-    ans = 64'hC34B14F95370BE22;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1643063\n");
-    end
-    x = 64'hC011F773A1BF66A5;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1643677\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hB7FA19DC3A5A0D78;
-    z = 64'h3FDF7EFFFFFFFFFF;
-    ans = 64'h3FDF7EFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1644291\n");
-    end
-    x = 64'hB028000000000FFF;
-    y = 64'h8010000000000001;
-    z = 64'hBFFFFF0000080000;
-    ans = 64'hBFFFFF0000080000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1644905\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hFFD0000400000003;
-    z = 64'h4000000000000001;
-    ans = 64'hFFE0000400000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1645519\n");
-    end
-    x = 64'hC1D0000000408000;
-    y = 64'h4CC000003FFFFF00;
-    z = 64'hBFBF7FC4A718A597;
-    ans = 64'hCEA0000040407F01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1646133\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1646747\n");
-    end
-    x = 64'hC80FFF0000000002;
-    y = 64'hDF00FFFFDFFFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'h6720FF77E0010000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1647361\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hBCA0000000000001;
-    z = 64'h3F8000000001FF00;
-    ans = 64'h3F8000000001FE80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1647975\n");
-    end
-    x = 64'hC03B661E51E64B35;
-    y = 64'hBF0FFFFFFF7FFFEF;
-    z = 64'h41B7EF43DA372A52;
-    ans = 64'h41B7EF43DA3797EA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1648589\n");
-    end
-    x = 64'h43CFFFFFFFFBFFFA;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1649203\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h572007FFFFFFFFEF;
-    z = 64'hC02C00B70D0083D1;
-    ans = 64'h573007FFFFFFFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1649817\n");
-    end
-    x = 64'hFFDFFFFFDBFFFFFF;
-    y = 64'hBFD0000000000000;
-    z = 64'h3CA0000020000008;
-    ans = 64'h7FBFFFFFDBFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1650431\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h3EB3A8C18215EEDE;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h400000013A8C1821;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1651045\n");
-    end
-    x = 64'hAFBF4F812341AB31;
-    y = 64'h3F104001FFFFFFFF;
-    z = 64'h80114411054D7F17;
-    ans = 64'hAEDFCCC311BED644;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1651659\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC013FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1652273\n");
-    end
-    x = 64'hC102BA21DE1A476C;
-    y = 64'hBECFFFFFF0000003;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h3FE2BA21D4BD367F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1652887\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hBFE0000000000000;
-    z = 64'hF9CFFFFF3FFFFFFE;
-    ans = 64'hF9CFFFFF3FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1653501\n");
-    end
-    x = 64'h393FFDFFFFFFF800;
-    y = 64'h004E11D80A9D5AFF;
-    z = 64'h41F00003FF7FFFFF;
-    ans = 64'h41F00003FF7FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1654115\n");
-    end
-    x = 64'hC8000000000041FF;
-    y = 64'hBFE0000000000001;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'h47F0000000004200;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1654729\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h43DFFFFFFFFFDFBF;
-    z = 64'hB800000000007FFC;
-    ans = 64'h43EFFFFFFFFFDFBD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1655343\n");
-    end
-    x = 64'h665FFFFFFFF7F000;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h41C000020001FFFE;
-    ans = 64'hE65FFFFFFFF7EFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1655957\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h401077A5A2BE365A;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h402277A5A2BE3659;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1656571\n");
-    end
-    x = 64'h061FFFFFC1FFFFFF;
-    y = 64'hC070000040000400;
-    z = 64'hBFBF810000000000;
-    ans = 64'hBFBF810000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1657185\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hBFF0000000000001;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1657799\n");
-    end
-    x = 64'h7FF6BBA8EE66553A;
-    y = 64'hD2200000017FFFFE;
-    z = 64'h8010000000000000;
-    ans = 64'h7FFEBBA8EE66553A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1658413\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hBFE00400000FFFFE;
-    ans = 64'hC01200800001FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1659027\n");
-    end
-    x = 64'h7FDA73B4F67E128A;
-    y = 64'h7FF1FFFFFFFFFFFD;
-    z = 64'hCABF7FF800000000;
-    ans = 64'h7FF9FFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1659641\n");
-    end
-    x = 64'hAF60000009FFFFFE;
-    y = 64'hC000000000000000;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1660255\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h3FC7DE7FE710E06E;
-    z = 64'h3FFBFFFEFFFFFFFE;
-    ans = 64'h4000FBCF7CE21C0D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1660869\n");
-    end
-    x = 64'hC04FFFFFFFC00007;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hC1E000000FFFFF80;
-    ans = 64'hC1DFFFFFDFFFFF00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1661483\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h3FCC000010000000;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FEE000007FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1662097\n");
-    end
-    x = 64'hC3F2E37F64E0E0B4;
-    y = 64'hB96F00000FFFFFFE;
-    z = 64'hC1DFE00400000000;
-    ans = 64'hC1DFE00400000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1662711\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hC010000000000000;
-    z = 64'hBFF0000000000000;
-    ans = 64'hC021FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1663325\n");
-    end
-    x = 64'hB7BFDFFFFFFF0000;
-    y = 64'hA7FF7FFEFFFFFFFE;
-    z = 64'h8000000000000001;
-    ans = 64'h1FCF607F00FF03FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1663939\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hEC562C4E9A8A0F85;
-    ans = 64'hEC562C4E9A8A0F85;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1664553\n");
-    end
-    x = 64'hBDB000000FFFFC00;
-    y = 64'h402A95C63B51BA70;
-    z = 64'hB816D59A68BD29ED;
-    ans = 64'hBDEA95C655E77A06;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1665167\n");
-    end
-    x = 64'hC1C2DEC562387EB0;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hC010000000000001;
-    ans = 64'h41F2DEC561F87EAF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1665781\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hBCAFF0000007FFFE;
-    z = 64'h403FBFFFFFBFFFFF;
-    ans = 64'h403FBFFFFFBFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1666395\n");
-    end
-    x = 64'hC1BFDFF7FFFFFFFF;
-    y = 64'hC340000000000001;
-    z = 64'hFFD20668823AB724;
-    ans = 64'hFFD20668823AB724;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1667009\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h45F7FFC000000000;
-    z = 64'h3FD0000000000001;
-    ans = 64'h4607FFBFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1667623\n");
-    end
-    x = 64'hC340000000107FFF;
-    y = 64'h40DD42F951360FAA;
-    z = 64'h40FFFFDFFFFFFFFB;
-    ans = 64'hC42D42F951543CB5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1668237\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hBFE0000000000001;
-    ans = 64'hC35FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1668851\n");
-    end
-    x = 64'hBFDFF02000000000;
-    y = 64'hC3EFFFFFFFFFFB7F;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1669465\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hFFE0000000000001;
-    z = 64'hC020088000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1670079\n");
-    end
-    x = 64'hC7EFFFFFE00003FF;
-    y = 64'hC1F1FFF7FFFFFFFE;
-    z = 64'h3CBE81B9C620397C;
-    ans = 64'h49F1FFF7EE000A3D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1670693\n");
-    end
-    x = 64'hC342F1C3ADA6D99F;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1671307\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h3C8FE1FFFFFFFFFF;
-    z = 64'h39C07FEFFFFFFFFF;
-    ans = 64'h3C9FE20000000081;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1671921\n");
-    end
-    x = 64'hA2345AA3A1084924;
-    y = 64'hFFF0000000000000;
-    z = 64'hB8104000FFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1672535\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'h41CBFFFFFFFFE000;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h41DBFFFFFFFFDFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1673149\n");
-    end
-    x = 64'hB96FFFFFFFFFF77E;
-    y = 64'h49AFFFBFFFFE0000;
-    z = 64'h5CDF7FEFFFFFFFFF;
-    ans = 64'h5CDF7FEFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1673763\n");
-    end
-    x = 64'h3FFFFFFFFFFFFFFE;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1674377\n");
-    end
-    x = 64'h400FFFC0000FFFFE;
-    y = 64'h802FE000001FFFFF;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1674991\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h0000000000000000;
-    z = 64'h001000FFFFFC0000;
-    ans = 64'h001000FFFFFC0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1675605\n");
-    end
-    x = 64'h37E743D23F8C0702;
-    y = 64'h407042B6B14E36BF;
-    z = 64'hB3EFFFFFF7FFFFBF;
-    ans = 64'h3867A4D3A819BB92;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1676219\n");
-    end
-    x = 64'h524001FF00000000;
-    y = 64'h0000000000000001;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1676833\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h4F02493E952EEE02;
-    z = 64'h0A9F0000FFFFFFFF;
-    ans = 64'h4F12493E952EEE02;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1677447\n");
-    end
-    x = 64'hBFD3DB57D4E982A8;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h801FF80000007FFF;
-    ans = 64'h8022776AFA9D7054;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1678061\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h0AEFF00000040000;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h0AFFF00000040000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1678675\n");
-    end
-    x = 64'h37EFFFFFFFC03FFF;
-    y = 64'h41E000003FFC0000;
-    z = 64'hC3DFFF0000000100;
-    ans = 64'hC3DFFF0000000100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1679289\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h0010000000000001;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBCAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1679903\n");
-    end
-    x = 64'h41EB000000000000;
-    y = 64'h4063494AAD05F0DE;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1680517\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h41EFFFFF00007FFF;
-    ans = 64'h41EFFFFF00007FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1681131\n");
-    end
-    x = 64'hC341FFFFFFFDFFFF;
-    y = 64'h002FFFFFFF7FBFFF;
-    z = 64'hC03112A588EFBE99;
-    ans = 64'hC03112A588EFBE99;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1681745\n");
-    end
-    x = 64'h001C0C4BE24F40FD;
-    y = 64'h3CA0000000000000;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1682359\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h3FF524055197547C;
-    z = 64'hBF1EB55F1B5292BA;
-    ans = 64'h400523C7E6D91DD7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1682973\n");
-    end
-    x = 64'hC0D50A2D635E365F;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h41F6244AC1402982;
-    ans = 64'h41F6244AC1402982;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1683587\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h3FE0000007C00000;
-    z = 64'h0010000000000000;
-    ans = 64'h3FF0000007C00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1684201\n");
-    end
-    x = 64'hB80FE000001FFFFE;
-    y = 64'hBFF00000107FFFFF;
-    z = 64'h405000040000000F;
-    ans = 64'h405000040000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1684815\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h3FD0000000000000;
-    z = 64'hBCA0000000000000;
-    ans = 64'h3FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1685429\n");
-    end
-    x = 64'hBFDFFBFFFFFBFFFF;
-    y = 64'h480FFDFFFFFFFF00;
-    z = 64'h4340000000000001;
-    ans = 64'hC7FFFA003FFBFF3F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1686043\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h000F6C9C104B7ABB;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1686657\n");
-    end
-    x = 64'hC02FFFFFFF080000;
-    y = 64'h43EAECF0AEF79302;
-    z = 64'hFFDFFFFFF00001FF;
-    ans = 64'hFFDFFFFFF00001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1687271\n");
-    end
-    x = 64'h3CA00FFDFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1687885\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h0001B09F750C484A;
-    z = 64'hBFCFF80001FFFFFF;
-    ans = 64'hBFCFF80001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1688499\n");
-    end
-    x = 64'h403FF80001FFFFFF;
-    y = 64'h3FE0000000000001;
-    z = 64'h41CFFFEFFFFFE000;
-    ans = 64'h41CFFFF007FDE001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1689113\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h425EFFFFFFFFFFBF;
-    z = 64'h0000000000000001;
-    ans = 64'h426EFFFFFFFFFFBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1689727\n");
-    end
-    x = 64'h43F2000000000100;
-    y = 64'hC0AFBFFFFFFFFFFE;
-    z = 64'hC01FE0000007FFFF;
-    ans = 64'hC4B1DC00000000FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1690341\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h8010000000000001;
+    ReadData1E = 64'h801FFFD800000000;
+    ReadData2E = 64'h3FCFFFFFFDFFFFFD;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
     ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1690955\n");
+    	$fwrite(fp,"1037951\n");
     end
-    x = 64'hC020003FF7FFFFFF;
-    y = 64'hC7E803FFFFFFFFFE;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h4818046003FDFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1691569\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h3FF0000000000001;
-    z = 64'hC028C4AD1E629470;
-    ans = 64'hC024C4AD1E629470;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1692183\n");
-    end
-    x = 64'h41EFF80000010000;
-    y = 64'h41FFFFFFC000FFFE;
-    z = 64'hB81FFFFF03FFFFFE;
-    ans = 64'h43FFF7FFC011FFBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1692797\n");
-    end
-    x = 64'h7FDE000000000FFE;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'h7FEE000000000FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1693411\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h466FFFFF77FFFFFE;
-    z = 64'h41F0000040200000;
-    ans = 64'h467FFFFF77FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1694025\n");
-    end
-    x = 64'hC1CFFFFDDFFFFFFF;
-    y = 64'h4000000000000000;
-    z = 64'hBEBA2BDB90324F31;
-    ans = 64'hC1DFFFFDE0000006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1694639\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h37E0000000008FFF;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1695253\n");
-    end
-    x = 64'h43D0000008000FFE;
-    y = 64'hB81FFFFF7FFFFF80;
-    z = 64'hC3E0007FFFFFBFFE;
-    ans = 64'hC3E0007FFFFFBFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1695867\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1696481\n");
-    end
-    x = 64'hC281963398C5F833;
-    y = 64'hC3C0000100000003;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h46519634B22931C3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1697095\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h4010000000000000;
-    z = 64'hBAFFFFC000000010;
-    ans = 64'h4020000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1697709\n");
-    end
-    x = 64'h400F800001FFFFFE;
-    y = 64'hBCA0000000000090;
-    z = 64'h53400000801FFFFF;
-    ans = 64'h53400000801FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1698323\n");
-    end
-    x = 64'h35E0004003FFFFFE;
-    y = 64'h4010000000000001;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBCAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1698937\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h37FFFFFBFFDFFFFE;
-    z = 64'hBFB9F6ED561680FF;
-    ans = 64'hBFB9F6ED561680FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1699551\n");
-    end
-    x = 64'h7FD00000003DFFFF;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hBFD0FFFFFFFFFEFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1700165\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hBFB000FFFFFFFFC0;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1700779\n");
-    end
-    x = 64'hFFE000000008000E;
-    y = 64'h41F00000201FFFFF;
-    z = 64'h4730007800000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1701393\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h4340000000000001;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1702007\n");
-    end
-    x = 64'hCE41BA3F359D9A50;
-    y = 64'hC00E3FFFFFFFFFFF;
-    z = 64'h4000000000000000;
-    ans = 64'h4E60C20FC0AEFBDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1702621\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hBFCFF8000000003E;
-    ans = 64'h435FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1703235\n");
-    end
-    x = 64'hC345C210B27A7C55;
-    y = 64'hD04FFDFFFFFFFC00;
-    z = 64'hBFE7FFFE00000000;
-    ans = 64'h53A5C0B4916F51F5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1703849\n");
-    end
-    x = 64'h7FD0000000001FFB;
-    y = 64'h7FE0000000000000;
-    z = 64'hBCA0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1704463\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hC0001FFFFFFFFFDF;
-    z = 64'h3E3000007FFFF7FF;
-    ans = 64'hC0101FFFFFBFFFDD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1705077\n");
-    end
-    x = 64'h37FB660C620F438B;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h436FFFFFF7FFFBFF;
-    ans = 64'h77FB660C620F438A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1705691\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hBE9E5650DF91EE0C;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1706305\n");
-    end
-    x = 64'hC7E0008080000000;
-    y = 64'hC629AB6B7F281634;
-    z = 64'h001001FF7FFFFFFF;
-    ans = 64'h4E19AC39A7DF6B6E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1706919\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h7FF0000000000000;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1707533\n");
-    end
-    x = 64'h3FCDD2DC2964A124;
-    y = 64'h43D0000038000000;
-    z = 64'h3FF0000000000001;
-    ans = 64'h43ADD2DC91C6A3B5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1708147\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h4C2FFFFF7FFFFFBF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1708761\n");
-    end
-    x = 64'hE3E00FFFFFFC0000;
-    y = 64'hC3D000000000005E;
-    z = 64'h4A4D8898DFF8B465;
-    ans = 64'h67C00FFFFFFC005E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1709375\n");
-    end
-    x = 64'h001000080001FFFE;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h8010000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1709989\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h3FF00000107FFFFF;
-    z = 64'hC03FEFFFFE000000;
-    ans = 64'hC03DEFFFFBF00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1710603\n");
-    end
-    x = 64'h47FF17EBE05658B2;
-    y = 64'h8000000000000001;
-    z = 64'h6C2FFFFFFFFFF5FE;
-    ans = 64'h6C2FFFFFFFFFF5FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1711217\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hC2AFFFFFFFFFFCFE;
-    z = 64'hC340000000000001;
-    ans = 64'hC3400FFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1711831\n");
-    end
-    x = 64'h3204CCAB7A4D2D0C;
-    y = 64'hBC01FFFFFFFFFDFE;
-    z = 64'hFFEF7FFFFFF7FFFF;
-    ans = 64'hFFEF7FFFFFF7FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1712445\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1713059\n");
-    end
-    x = 64'hBFF000007DFFFFFF;
-    y = 64'hBFE89D55BBC01104;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FFC4EAB3ECB8A14;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1713673\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h8010000000000000;
-    z = 64'h380FFF00000001FF;
-    ans = 64'h380FFF00000001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1714287\n");
-    end
-    x = 64'hB9B000080000003F;
-    y = 64'hB93FFFFFFFFE0001;
-    z = 64'hBFD1698896277BD3;
-    ans = 64'hBFD1698896277BD3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1714901\n");
-    end
-    x = 64'h400FEFE000000000;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h8041F7EFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1715515\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h40D00000000FFF7E;
-    z = 64'h40000000003FDFFF;
-    ans = 64'h40E000400010007D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1716129\n");
-    end
-    x = 64'hC723258BFDA071ED;
-    y = 64'hBCA0000000000000;
-    z = 64'h3FB0000000200001;
-    ans = 64'h43D3258BFDA071ED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1716743\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h80200101FFFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1717357\n");
-    end
-    x = 64'h41E0000DFFFFFFFF;
-    y = 64'h412000000000801E;
-    z = 64'hBFAFFFFFFFFE0007;
-    ans = 64'h4310000E0000801D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1717971\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1718585\n");
-    end
-    x = 64'hFFEFFFFFFFFFF7FE;
-    y = 64'h47F000000003FFFF;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1719199\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hB16000003FFFFFFF;
-    ans = 64'hBCBFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1719813\n");
-    end
-    x = 64'h43C53AE0E828B89B;
-    y = 64'hB8D2000000010000;
-    z = 64'h400FEFFFFFFFFFFD;
-    ans = 64'h400FEFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1720427\n");
-    end
-    x = 64'h016BFFFFFFFFBFFF;
-    y = 64'hBFD0000000000001;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1721041\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h47E001FFFF800000;
-    z = 64'h480420C387510B53;
-    ans = 64'h480C21C387110B53;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1721655\n");
-    end
-    x = 64'hC3C087FFFFFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'hC02FFFFFFFFFFFF2;
-    ans = 64'h43B087FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1722269\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h7FE0000037FFFFFE;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1722883\n");
-    end
-    x = 64'hC1DFFFFEFFFF7FFE;
-    y = 64'h402FFFFFDEFFFFFF;
-    z = 64'h4F515204563A7F36;
-    ans = 64'h4F515204563A7F36;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1723497\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hBFE0000000000001;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401BFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1724111\n");
-    end
-    x = 64'h40100200000007FF;
-    y = 64'h47EFF7FFFFFFFFF0;
-    z = 64'h3FD0000000000000;
-    ans = 64'h480FFBFF00000FEA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1724725\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h401FFFFFFF880000;
-    ans = 64'h4017FFFFFF880000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1725339\n");
-    end
-    x = 64'hB806261012190A5F;
-    y = 64'hC343FFFFFFFFFFDE;
-    z = 64'h402830644E65DDF0;
-    ans = 64'h402830644E65DDF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1725953\n");
-    end
-    x = 64'h47F927AEB72E590C;
-    y = 64'hBFF0000000000000;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1726567\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h755EA63AFBFA49E3;
-    z = 64'h6FBFFFE000000000;
-    ans = 64'h756EA63AFBFA49E3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1727181\n");
-    end
-    x = 64'hC1DFFFFFFC000800;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h8151008000000000;
-    ans = 64'h41EFFFFFFC0007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1727795\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hBFE00000FFBFFFFE;
-    z = 64'hC000000000000000;
-    ans = 64'hC00800007FDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1728409\n");
-    end
-    x = 64'hC4E00000004007FF;
-    y = 64'hB7E400000000007F;
-    z = 64'h37E0000000040002;
-    ans = 64'h3CD4000000500A7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1729023\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hC000000000000000;
-    z = 64'h4010000000000000;
-    ans = 64'h0000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1729637\n");
-    end
-    x = 64'h47F9AFC4E5492F7B;
-    y = 64'h409E22E8C3182C5E;
-    z = 64'h3CA0000000000001;
-    ans = 64'h48A830CE2F1637DE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1730251\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hC000000000000001;
-    z = 64'hBF6FFFFF5FFFFFFF;
-    ans = 64'hC01003FFFFEC0001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1730865\n");
-    end
-    x = 64'h4030000002000000;
-    y = 64'hC25FFFDFFFFFFFFF;
-    z = 64'hC0040000001FFFFF;
-    ans = 64'hC29FFFE0040005FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1731479\n");
-    end
-    x = 64'h4010000400000006;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1732093\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h43F0FFFFFEFFFFFF;
-    z = 64'h3FBFFFFE00000002;
-    ans = 64'h4400FFFFFEFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1732707\n");
-    end
-    x = 64'h40300146660A8F48;
-    y = 64'hC010000000000000;
-    z = 64'hBFC00FFFFFFFF800;
-    ans = 64'hC050094E660A8F44;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1733321\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h25F0DFEF7CAE8B52;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1733935\n");
-    end
-    x = 64'hC3F0800003FFFFFF;
-    y = 64'h40F00000001EFFFF;
-    z = 64'hC18FFFFFFFFDEFFF;
-    ans = 64'hC4F08000041FF7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1734549\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h4000000000000001;
-    ans = 64'hC02BFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1735163\n");
-    end
-    x = 64'hC37FFFFFFFF3FFFF;
-    y = 64'h401FFFFFFFFFF600;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'hC3AFFFFFFFF3F5FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1735777\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hC340000000000000;
-    z = 64'h4031000008000000;
-    ans = 64'hC34FFFFFFFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1736391\n");
-    end
-    x = 64'hBFBFFFFF8000FFFF;
-    y = 64'h404000004000000F;
-    z = 64'h3C1FC1FFFFFFFFFE;
-    ans = 64'hC010000000007F0F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1737005\n");
-    end
-    x = 64'h7CCFFFFFFFFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1737619\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h2ADFC00004000000;
-    z = 64'hB16FFFFFE00FFFFF;
-    ans = 64'hB16FFFFFE00FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1738233\n");
-    end
-    x = 64'hC3DF7FFBFFFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hBFC0DB4FA7E69FC7;
-    ans = 64'h473F7FFBFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1738847\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hC1FFFFFDFFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hC20FFFFE0007FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1739461\n");
-    end
-    x = 64'h3F0077FFFFFFFFFF;
-    y = 64'h3FCC000000020000;
-    z = 64'h43DF1D64DBAB2499;
-    ans = 64'h43DF1D64DBAB2499;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1740075\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1740689\n");
-    end
-    x = 64'h41F400000001FFFE;
-    y = 64'h40800FFFFEFFFFFF;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h428413FFFEC201FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1741303\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hC06FFFFDFFFFFE00;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1741917\n");
-    end
-    x = 64'h3F70000F7FFFFFFE;
-    y = 64'h40FE955D3D060580;
-    z = 64'h3FD0FFFFFDFFFFFE;
-    ans = 64'h407E99BADDB7D89A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1742531\n");
-    end
-    x = 64'hC7E0FFFFE0000000;
-    y = 64'hFFF0000000000001;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1743145\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'hC3FF3DB5443DB0CB;
-    z = 64'h43ECD85389B5C822;
-    ans = 64'hC40807A061D03EC2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1743759\n");
-    end
-    x = 64'hC7FFFFFFF0001FFE;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h0000006FFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1744373\n");
-    end
-    x = 64'h4000000000000000;
-    y = 64'h5851433A0C36872F;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'h5861433A0C36872F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1744987\n");
-    end
-    x = 64'hC09FF7BFFFFFFFFF;
-    y = 64'h3800000000000FC0;
-    z = 64'hBE7000000000000E;
-    ans = 64'hBE7000000000000E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1745601\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h0000000000000001;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h3FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1746215\n");
-    end
-    x = 64'hFFD9F43EFD1ADAF1;
-    y = 64'h3FF4CC80FA5A7FC4;
-    z = 64'h0000000000000000;
-    ans = 64'hFFE0DE850BC7DB21;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1746829\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hC18FFFFFFFCFFFFE;
-    ans = 64'hC18FFFFFFFCFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1747443\n");
-    end
-    x = 64'hC51F224DF686F6E9;
-    y = 64'hBF77FFFFFFFFFBFF;
-    z = 64'h3811FFFFFFFFEFFF;
-    ans = 64'h44A759BA78E53549;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1748057\n");
-    end
-    x = 64'hC800000000007FFB;
-    y = 64'h0010000000000000;
-    z = 64'h4010000000000000;
-    ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1748671\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h38900000000FFFBF;
-    z = 64'h331583B66DB45ACA;
-    ans = 64'h38A00000000FFFC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1749285\n");
-    end
-    x = 64'hC00FFFFFFC002000;
-    y = 64'h0010000000000001;
-    z = 64'h813DEEFF25B99912;
-    ans = 64'h813DEF0F25B99712;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1749899\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h400000000100007F;
-    z = 64'hBFD0000000000000;
-    ans = 64'h400E000002000100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1750513\n");
-    end
-    x = 64'hC7E0FFFFFF7FFFFF;
-    y = 64'h3F89E348A0C8D43A;
-    z = 64'h801FB486830D7FB5;
-    ans = 64'hC77B817D2A064737;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1751127\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h3CA0000000000000;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1751741\n");
-    end
-    x = 64'h436D6341228748EE;
-    y = 64'h242000000FFFBFFF;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1752355\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h3CA0000000000001;
-    z = 64'h43D0000000004400;
-    ans = 64'h43D0000000004400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1752969\n");
-    end
-    x = 64'h801FFFFFBF000000;
-    y = 64'h4012B6DA70C3DECC;
-    z = 64'h0000000000000006;
-    ans = 64'h8042B6DA4AC07316;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1753583\n");
-    end
-    x = 64'hBFDF803FFFFFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1754197\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h358FFFFFEFFFFFFE;
-    z = 64'hBF8FFFFFFFFFFFFE;
-    ans = 64'hBF8FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1754811\n");
-    end
-    x = 64'hBFCFFEFFFFFFF7FE;
-    y = 64'h3FD0000000000000;
-    z = 64'h3FDFFFFFFFFF77FF;
-    ans = 64'h3FDC001FFFFF78FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1755425\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h3FCFFFFFFFFC01FF;
-    z = 64'hBCA0000000000001;
-    ans = 64'h3FDFFFFFFFFC01FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1756039\n");
-    end
-    x = 64'h37F0000000801FFF;
-    y = 64'h37EFFFFFF001FFFF;
-    z = 64'h800FFFFFC0FFFFFE;
-    ans = 64'h2FEFFFFFF1023FFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1756653\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FF4000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1757267\n");
-    end
-    x = 64'h43D0000004800000;
-    y = 64'hB91FFBFFFFFFFEFE;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1757881\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h3FE0000000000000;
-    z = 64'hC3D000000077FFFF;
-    ans = 64'hC3D000000077FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1758495\n");
-    end
-    x = 64'h3FB00000040003FF;
-    y = 64'h3FD0000020800000;
-    z = 64'h3FEFF7FFFFEFFFFF;
-    ans = 64'h3FF03C00008A0010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1759109\n");
-    end
-    x = 64'hAB0FFFFFF0100000;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h3FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1759723\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hC1C5B002CE2BD351;
-    z = 64'hB80337F20C2B93AE;
-    ans = 64'hC1D5B002CE2BD352;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1760337\n");
-    end
-    x = 64'h4800000400400000;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hC3CBC6C815066223;
-    ans = 64'h48000004003FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1760951\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hBFDFFF7FFFFFFFFD;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'hBFEFFF7FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1761565\n");
-    end
-    x = 64'h400F9D7BCAC61F20;
-    y = 64'h47FF0000001FFFFF;
-    z = 64'hC00D1C5E24468EF4;
-    ans = 64'h481EA08FEC8F8BA2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1762179\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1762793\n");
-    end
-    x = 64'h3FF01FFFFFFFFF7F;
-    y = 64'h400FFFFFFFFEFFFC;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1763407\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h4030000010000400;
-    ans = 64'h4034000010000400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1764021\n");
-    end
-    x = 64'h8000000000000407;
-    y = 64'hBFDFFFFFFFFFFEE0;
-    z = 64'hBFBF0000000FFFFF;
-    ans = 64'hBFBF0000000FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1764635\n");
-    end
-    x = 64'h544A3DA4E3B766A1;
-    y = 64'h4000000000000001;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h545A3DA4E3B766A3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1765249\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h46CAC970B49DD3AD;
-    z = 64'hC0AFFFFFFFFFE00F;
-    ans = 64'h46DAC970B49DD3AF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1765863\n");
-    end
-    x = 64'h8000000000020000;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h41FFFFFFFC00FFFF;
-    ans = 64'h41FFFFFFFC00FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1766477\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hB7EFFFE001FFFFFF;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hB7FFFFE002000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1767091\n");
-    end
-    x = 64'hC00FFFFC0000001F;
-    y = 64'h7FF00FFFFFFFBFFF;
-    z = 64'hC08FFF7FFFFFFFFA;
-    ans = 64'h7FF80FFFFFFFBFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1767705\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h4010000000000001;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h4020000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1768319\n");
-    end
-    x = 64'h37F1FFFFFFFFBFFF;
-    y = 64'h15EFFFFF9FFFFFFF;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1768933\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hBFF1000010000000;
-    ans = 64'h402DDFFFFE000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1769547\n");
-    end
-    x = 64'h75FFFFFF80007FFE;
-    y = 64'hC01FFFE000008000;
-    z = 64'h41F3FFFFFFFFEFFF;
-    ans = 64'hF62FFFDF80017FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1770161\n");
-    end
-    x = 64'hB7EFFFC00000FFFF;
-    y = 64'h4340000000000000;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1770775\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hC00FF00000008000;
-    z = 64'h4010000001000000;
-    ans = 64'hC00FDFFFFE010004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1771389\n");
-    end
-    x = 64'h7FF237D206D36360;
-    y = 64'h4340000000000001;
-    z = 64'hC3C7716C2259F813;
-    ans = 64'h7FFA37D206D36360;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1772003\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hC3C0FFDFFFFFFFFF;
-    z = 64'h8000000000000000;
-    ans = 64'hC3D0FFE000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1772617\n");
-    end
-    x = 64'h414A3DD5DE82898B;
-    y = 64'h402F7EFFFFFFFFFE;
-    z = 64'h3CAFFEC000000000;
-    ans = 64'h4189D40C98598B4F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1773231\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h7FE0000000000000;
-    z = 64'h0010000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1773845\n");
-    end
-    x = 64'h3FD20000FFFFFFFF;
-    y = 64'hBEE000000000F7FE;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000090000801;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1774459\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h7FE0000000000001;
-    z = 64'h10D0000008000080;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1775073\n");
-    end
-    x = 64'h3E5FFF7FFFFFFFDE;
-    y = 64'h40AFFFFEFE000000;
-    z = 64'hBFD000000000000B;
-    ans = 64'hBFCFFC0010203F95;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1775687\n");
-    end
-    x = 64'hBFE050C5935F9B62;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h3FD0000000000001;
-    ans = 64'hFFE050C5935F9B61;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1776301\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h47FFFFFFFF7FFFEF;
-    z = 64'h6FF001FFFFFFFFFA;
-    ans = 64'h6FF001FFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1776915\n");
-    end
-    x = 64'hD7400007FFFFFFF7;
-    y = 64'h7FF0000000000000;
-    z = 64'h46200000017FFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1777529\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h402FFFFFFFFFFFD0;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1778143\n");
-    end
-    x = 64'h3FBFFFF7FFFFFFFA;
-    y = 64'hBF8FFFFF3FFFFFFF;
-    z = 64'hC34800000000001F;
-    ans = 64'hC34800000000001F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1778757\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h0000000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1779371\n");
-    end
-    x = 64'hC34FFFEFFFFFF7FE;
-    y = 64'hC000000000808000;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'h435FFFF00100F77C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1779985\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h8000000000000000;
-    z = 64'hBFEF62D1FFBD4AF4;
-    ans = 64'hBFEF62D1FFBD4AF4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1780599\n");
-    end
-    x = 64'h43F64D8FB8BB1136;
-    y = 64'hC49E1FFFFFFFFFFF;
-    z = 64'hC8000002003FFFFF;
-    ans = 64'hC8A503044D682B33;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1781213\n");
-    end
-    x = 64'hC0F0000000000407;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1781827\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hC02744F10D0CD258;
-    z = 64'h80276B5120A17EE2;
-    ans = 64'hC03744F10D0CD259;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1782441\n");
-    end
-    x = 64'hBFF0002000000000;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h415FFFFFE0000010;
-    ans = 64'h415FFFFFE0000010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1783055\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hC022000080000000;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1783669\n");
-    end
-    x = 64'hC02FFFF800000006;
-    y = 64'h40C0000010000FFF;
-    z = 64'hC01FFFFF8003FFFF;
-    ans = 64'hC100003C0FFF0C0A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1784283\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h8010000000000001;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1784897\n");
-    end
-    x = 64'hB7F800B345BCBFC9;
-    y = 64'h7FE9C88F81D7641E;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hF7F356FC1374D3A5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1785511\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h40A001FFFE000000;
-    ans = 64'h40A001FFFE000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1786125\n");
-    end
-    x = 64'h3810010400000000;
-    y = 64'h800A307BC417CC79;
-    z = 64'h412D6D16F2C3A035;
-    ans = 64'h412D6D16F2C3A035;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1786739\n");
-    end
-    x = 64'hBFE01003FFFFFFFF;
-    y = 64'hBCA0000000000001;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h3C90100400000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1787353\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hC3C000000001FF7F;
-    z = 64'h442FFFFF00000FFF;
-    ans = 64'h442F7FFF00000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1787967\n");
-    end
-    x = 64'hC3E0000007FDFFFE;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'hD8896E54EF85B595;
-    ans = 64'hD8896E54EF85B595;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1788581\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hBFC4000000004000;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1789195\n");
-    end
-    x = 64'h801003FFFFFFFFFB;
-    y = 64'hC02FFBFF00000000;
-    z = 64'hBC64A4C6EF2A4F02;
-    ans = 64'hBC64A4C6EF2A4F02;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1789809\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hBFD0000000000000;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1790423\n");
-    end
-    x = 64'h3FC2D2609C21B45C;
-    y = 64'h41DFFFFFFFC0FFFE;
-    z = 64'hBFF0000000000000;
-    ans = 64'h41B2D2609AFCA62D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1791037\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hC7F015AE3F3AD1AC;
-    ans = 64'hC7F015AE3F3AD1AC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1791651\n");
-    end
-    x = 64'h802FF80000003FFE;
-    y = 64'h3F20000800003FFE;
-    z = 64'h3F6423F1E5D3FBF4;
-    ans = 64'h3F6423F1E5D3FBF4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1792265\n");
-    end
-    x = 64'h3FC1E7598F9CD086;
-    y = 64'hBFE0000000000000;
-    z = 64'h0010000000000000;
-    ans = 64'hBFB1E7598F9CD086;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1792879\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h3FE003FFFF800000;
-    z = 64'hC01DFFEFFFFFFFFF;
-    ans = 64'hC019FEF0001FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1793493\n");
-    end
-    x = 64'hC000002FFFFFFFFF;
-    y = 64'hBFE0000000000001;
-    z = 64'hB7F000DFFFFFFFFE;
-    ans = 64'h3FF0003000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1794107\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hBFA0000000000FFB;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1794721\n");
-    end
-    x = 64'hC03DC1C014713559;
-    y = 64'hB7FFFFFFFC002000;
-    z = 64'h3F9FFFEFFFDFFFFE;
-    ans = 64'h3F9FFFEFFFDFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1795335\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1795949\n");
-    end
-    x = 64'h01F748C86FB03473;
-    y = 64'hC7FB8788D6F9E4E6;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1796563\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hBFF0000000000001;
-    z = 64'h3F5F800000040000;
-    ans = 64'hBFFFF81FFFFFFF04;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1797177\n");
-    end
-    x = 64'hBCA00000EFFFFFFF;
-    y = 64'h43C400003FFFFFFF;
-    z = 64'h3CA00007FFFFC000;
-    ans = 64'hC07400016C0003BE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1797791\n");
-    end
-    x = 64'hC1F3FFFFFFFFFFE0;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h0000000000000001;
-    ans = 64'h4203FFFFFFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1798405\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h43DF000007FFFFFE;
-    z = 64'h40100008FFFFFFFF;
-    ans = 64'h43EF000008000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1799019\n");
-    end
-    x = 64'hC3F2E23919B19F0E;
-    y = 64'hC000000000000000;
-    z = 64'h7FE98F5A17F2E86E;
-    ans = 64'h7FE98F5A17F2E86E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1799633\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h41E609ACC408B524;
-    z = 64'h4010000000000001;
-    ans = 64'h41F609ACC448B525;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1800247\n");
-    end
-    x = 64'h4080001003FFFFFE;
-    y = 64'hB81FFFF800080000;
-    z = 64'h40D1000000800000;
-    ans = 64'h40D1000000800000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1800861\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1801475\n");
-    end
-    x = 64'h8017FF8000000000;
-    y = 64'h747FFFFFFFFFFFFF;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1802089\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hC010000000000000;
-    z = 64'hBFEFFFFFFFFFFFE4;
-    ans = 64'hC021FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1802703\n");
-    end
-    x = 64'hC07000000100001F;
-    y = 64'hC0E4D4E49ACE0434;
-    z = 64'hBFCFFFFFDFFFFF80;
-    ans = 64'h4164D4E4941B52AE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1803317\n");
-    end
-    x = 64'h46B0027FFFFFFFFF;
-    y = 64'hC010000000000001;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1803931\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hBFD11F7A827D1E2E;
-    z = 64'h4005DD80C016477D;
-    ans = 64'h400195A21F76FFF1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1804545\n");
-    end
-    x = 64'hFFFE280615241B91;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h79AFFF03FFFFFFFE;
-    ans = 64'hFFFE280615241B91;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1805159\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hC7EBFFFE00000000;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'hC7FBFFFE00000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1805773\n");
-    end
-    x = 64'hBE27ECA300A3042F;
-    y = 64'hFFD60AAFC2B75EE4;
-    z = 64'h3E703FFFFFFEFFFF;
-    ans = 64'h7E107AAD6B0F65B7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1806387\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hC340000000000001;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC350000000000004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1807001\n");
-    end
-    x = 64'h402FF000001FFFFF;
-    y = 64'hCCAFF1B2E8DEC363;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hCCEFE1BA0F8A45B3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1807615\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h37E007FFFFFFFBFF;
-    ans = 64'hC360000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1808229\n");
-    end
-    x = 64'hBFBFEFFFFFFFFFFB;
-    y = 64'h117FFE000003FFFF;
-    z = 64'hC0107437118816CB;
-    ans = 64'hC0107437118816CB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1808843\n");
-    end
-    x = 64'hF4D0000400000FFE;
-    y = 64'hFFE0000000000000;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1809457\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hCA0FFFFFFDFFFBFF;
-    z = 64'h43E0000200000002;
-    ans = 64'hCA1FFFFFFDFFFC01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1810071\n");
-    end
-    x = 64'hB7EF275E3109EBEA;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hD600000FFFFFFFBF;
-    ans = 64'h77EF275E3109EBE9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1810685\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'h41F07FE000000000;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h42007FE000100001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1811299\n");
-    end
-    x = 64'hFFFFFFFFFFF7FFFA;
-    y = 64'h361FFFFFFFF0003E;
-    z = 64'hBFCDE782F05F6E29;
-    ans = 64'hFFFFFFFFFFF7FFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1811913\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hFFF0000000000000;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1812527\n");
-    end
-    x = 64'hBF83BAA79E85EC1A;
-    y = 64'h3FBFFFFFFFE003FE;
-    z = 64'hBCA0000000000000;
-    ans = 64'hBF53BAA79E7235E8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1813141\n");
-    end
-    x = 64'h4000000000000001;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h7FD8000000FFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1813755\n");
-    end
-    x = 64'hBFEFF5F3E00E51FC;
-    y = 64'h381AA9A05DB030CE;
-    z = 64'hC01FFFFFDFFFFF7F;
-    ans = 64'hC01FFFFFDFFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1814369\n");
-    end
-    x = 64'hB800001FFF7FFFFF;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1814983\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h7EEA3D84C3E981AE;
-    z = 64'h3FF0000000001F7F;
-    ans = 64'h7F0A3D84C3E981AD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1815597\n");
-    end
-    x = 64'hBFEFFFFFFFEFFFFC;
-    y = 64'h0000000000000001;
-    z = 64'h41B0001800000000;
-    ans = 64'h41B0001800000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1816211\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h37EFFFFFE0FFFFFF;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1816825\n");
-    end
-    x = 64'h5BE66EEA72E09608;
-    y = 64'h4346A605EF720221;
-    z = 64'h001FFFFF03FFFFFE;
-    ans = 64'h5F3FC14970BE939C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1817439\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1818053\n");
-    end
-    x = 64'hD0C00FFFEFFFFFFE;
-    y = 64'h434FFFEFFFFFFBFE;
-    z = 64'h8010000000000001;
-    ans = 64'hD4200FF7E80005FB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1818667\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h0010000000000001;
-    z = 64'h43D844324AC65C66;
-    ans = 64'h43D844324AC65C66;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1819281\n");
-    end
-    x = 64'hC03A841F0672CCEA;
-    y = 64'hBFFFEFFFFFDFFFFE;
-    z = 64'hC10E000200000000;
-    ans = 64'hC10DFE5A923092AF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1819895\n");
-    end
-    x = 64'h91C0000004008000;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1820509\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hB81002003FFFFFFF;
-    z = 64'h2C58001FFFFFFFFF;
-    ans = 64'hB83002003FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1821123\n");
-    end
-    x = 64'h3CAFEFFFFFFFFFE0;
-    y = 64'h3CA0000000000000;
-    z = 64'h3040000000000000;
-    ans = 64'h395FEFFFFFFFFFE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1821737\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hB7EFFFFFE0200000;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1822351\n");
-    end
-    x = 64'hC80FFFFFE0000002;
-    y = 64'hBF0B6637E256754F;
-    z = 64'h37F66727FC897D25;
-    ans = 64'h472B6637C6F03D6E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1822965\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFEFFFFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1823579\n");
-    end
-    x = 64'h415F800000000100;
-    y = 64'hC3E0000FFF000000;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'hC54F801F7E080100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1824193\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h3FD0000000000000;
-    z = 64'h37EBFFFFFFFFFFFC;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1824807\n");
-    end
-    x = 64'h3FE4116E93E56F17;
-    y = 64'h3FCF7FFFF8000000;
-    z = 64'hC0201007FFFFFFFE;
-    ans = 64'hC01F8206B95B740E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1825421\n");
-    end
-    x = 64'h358000007FFFDFFF;
-    y = 64'h3FD0000000000001;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1826035\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hC1CFFFF000000040;
-    z = 64'h7FDECC2967860F7E;
-    ans = 64'h7FDECC2967860F7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1826649\n");
-    end
-    x = 64'h3810000003FFFFFD;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h3FC00000001FFE00;
-    ans = 64'h3FC00000001FFE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1827263\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hC62FFFF804000000;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'hC64FFFF803FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1827877\n");
-    end
-    x = 64'hBFF81F36391021FB;
-    y = 64'h4050004FFFFFFFFF;
-    z = 64'h6C0FFF807FFFFFFF;
-    ans = 64'h6C0FFF807FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1828491\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h3FE0000000000001;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1829105\n");
-    end
-    x = 64'hC020000000FBFFFE;
-    y = 64'h407EEFFFFFFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1829719\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h6BD0400000010000;
-    ans = 64'h6BD0400000010000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1830333\n");
-    end
-    x = 64'h4D069B23F868B6DD;
-    y = 64'hC2600020000FFFFF;
-    z = 64'h0022F3A10B222F4A;
-    ans = 64'hCF769B512EC742D1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1830947\n");
-    end
-    x = 64'h372FFFFFFFFE007F;
-    y = 64'h3FF0000000000000;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1831561\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hC3EFFFFF7FFFFEFF;
-    z = 64'hC0E2E2D8FDDA0A73;
-    ans = 64'hC40FFFFF7FFFFF03;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1832175\n");
-    end
-    x = 64'h43C00000007F7FFE;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hBFE20FF482B66D99;
-    ans = 64'h43D00000007F7FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1832789\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hC3EA35D616039DF4;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'hC40A35D616039DF3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1833403\n");
-    end
-    x = 64'hFFEFFFFEFFEFFFFF;
-    y = 64'hBFDC7B63D40DC944;
-    z = 64'h4460040000000004;
-    ans = 64'h7FDC7B62F0246CF1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1834017\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h4000000000000000;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'h401DFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1834631\n");
-    end
-    x = 64'h402FFFFFFFFFFEFE;
-    y = 64'h4000007FFFF80000;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1835245\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h800C6068B41C7BB7;
-    ans = 64'h402FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1835859\n");
-    end
-    x = 64'h373CE9EB12A75385;
-    y = 64'hEAC0002007FFFFFE;
-    z = 64'hAC7007FFBFFFFFFF;
-    ans = 64'hE20CEA24F4F26E59;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1836473\n");
-    end
-    x = 64'h2BB0800000000800;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1837087\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h4B7FFFFFFFFFF03E;
-    z = 64'h3CE080000000FFFF;
-    ans = 64'h4B9FFFFFFFFFF03D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1837701\n");
-    end
-    x = 64'h4530037FFFFFFFFE;
-    y = 64'h4010000000000001;
-    z = 64'hBF700200000001FF;
-    ans = 64'h4550037FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1838315\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hFFEF0000003FFFFF;
-    z = 64'h3CA0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1838929\n");
-    end
-    x = 64'h3810000001FFFBFF;
-    y = 64'h57E000F800000000;
-    z = 64'h403000000000C000;
-    ans = 64'h500000F802001AFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1839543\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hBFD0000000000000;
-    ans = 64'h403FBFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1840157\n");
-    end
-    x = 64'h3FCFFFFFFFFF00FE;
-    y = 64'hC34000FFFFFFFFFD;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1840771\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h4340000000000001;
-    z = 64'h7FFFFFFFFFFFFFDC;
-    ans = 64'h7FFFFFFFFFFFFFDC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1841385\n");
-    end
-    x = 64'hC34AA4AD5429CD0E;
-    y = 64'h002FFFFC00FFFFFE;
-    z = 64'h0010100000200000;
-    ans = 64'h838AA4AA006947F2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1841999\n");
-    end
-    x = 64'hC34FFFF800000010;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hBFF0000000000001;
-    ans = 64'hC6AFFFF80000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1842613\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h638FFFFFFAFFFFFF;
-    z = 64'hC1CFFFFFF8007FFE;
-    ans = 64'h63AFFFFFFAFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1843227\n");
-    end
-    x = 64'hB7FF7FFFFFFFF000;
-    y = 64'h7FE0000000000000;
-    z = 64'h78B01FFFEFFFFFFF;
-    ans = 64'h78B01F03F0000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1843841\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hBFCFFFFF04000000;
-    z = 64'h0010000000000001;
-    ans = 64'hBFEFFFFF03FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1844455\n");
-    end
-    x = 64'h3806DE6D558BFE8E;
-    y = 64'hC06FB4D241F29CCB;
-    z = 64'h3C7C9728EFA05491;
-    ans = 64'h3C7C9728EFA05491;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1845069\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hBCA0000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1845683\n");
-    end
-    x = 64'hBFD0000FFF7FFFFE;
-    y = 64'h5500001FFFFFBFFF;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'hD4E0002FFF9FBEFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1846297\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h7FF0000000000000;
-    z = 64'h37EB9B5ABEC6C2F2;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1846911\n");
-    end
-    x = 64'h7FD00005FFFFFFFE;
-    y = 64'h41FFFFFFFFFFFFFF;
-    z = 64'h43DFFFF7FFFFFFBF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1847525\n");
-    end
-    x = 64'hC1EFFFFFFF81FFFE;
-    y = 64'h7FF0000000000001;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1848139\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h7FF00000000107FF;
-    z = 64'hC01000FFFFFFFF00;
-    ans = 64'h7FF80000000107FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1848753\n");
-    end
-    x = 64'hC34DFFFFFFF80000;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h40B0003FFFFFDFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1849367\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h7FDFFEEFFFFFFFFF;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1849981\n");
-    end
-    x = 64'h4800000010000040;
-    y = 64'h400ED4F0320ECE0D;
-    z = 64'h4345D3E889C98140;
-    ans = 64'h481ED4F050E3BEBA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1850595\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h8000000000000001;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h8020000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1851209\n");
-    end
-    x = 64'hFFE004000000001F;
-    y = 64'hD01D0009A1468219;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1851823\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h7F20001040000000;
-    ans = 64'h7F20001040000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1852437\n");
-    end
-    x = 64'hB80F1FFFFFFFFFFE;
-    y = 64'h3F8000000007FDFF;
-    z = 64'hB7F000FFFFFFDFFF;
-    ans = 64'hB7F07D8000001E2F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1853051\n");
-    end
-    x = 64'hB8000000000017FF;
-    y = 64'h8010000000000000;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1853665\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hC1EFFFF900000000;
-    z = 64'h3FF9BEB5ED8496DD;
-    ans = 64'hC20FFFF8FFF320A4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1854279\n");
-    end
-    x = 64'h380FC00003FFFFFF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h3FC54CA808F073E0;
-    ans = 64'h3FC54CA808F073E0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1854893\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h381F7FBFFFFFFFFF;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1855507\n");
-    end
-    x = 64'h375FFFDFFFF7FFFF;
-    y = 64'hC3EFFFFFFFBFFFF6;
-    z = 64'h38EF7F0000000000;
-    ans = 64'hBB5FFFDFFFB7C137;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1856121\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hBCA0000000000000;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hBCBFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1856735\n");
-    end
-    x = 64'hBFE0000000000000;
-    y = 64'h40303FFFDFFFFFFE;
-    z = 64'h4010000000000000;
-    ans = 64'hC0107FFFBFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1857349\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'hC031FFFFF7FFFFFF;
-    ans = 64'hC031FFFFF7FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1857963\n");
-    end
-    x = 64'h3E1DFFFFFFFEFFFF;
-    y = 64'h816FFFFF7FFFFBFE;
-    z = 64'h3F4FFEFFFFFFBFFE;
-    ans = 64'h3F4FFEFFFFFFBFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1858577\n");
-    end
-    x = 64'h37FFA1D0ECBF6C4F;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1859191\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h3810CD5B23763DB0;
-    z = 64'h37FDDD58B748F787;
-    ans = 64'h3832AB30AEEACD28;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1859805\n");
-    end
-    x = 64'hC1F000403FFFFFFF;
-    y = 64'hBFD0000000000001;
-    z = 64'h43400001FFFF0000;
-    ans = 64'h434000021FFF8080;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1860419\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h7122319B49C3C14C;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1861033\n");
-    end
-    x = 64'hBF100FFFF7FFFFFF;
-    y = 64'hC00FFFC0000003FE;
-    z = 64'hA5AFFFFE0001FFFE;
-    ans = 64'h3F300FDFD8001200;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1861647\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h8000000000000000;
-    ans = 64'hBFFFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1862261\n");
-    end
-    x = 64'h3FFE000000000100;
-    y = 64'h0000004007FFFFFE;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1862875\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hBFE0000000000001;
-    z = 64'h403FFFFFFC000080;
-    ans = 64'h403DFFFFFC000080;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1863489\n");
-    end
-    x = 64'h417063B4BEBF8A2B;
-    y = 64'h7FDFFFFFFFFFF004;
-    z = 64'hB990040080000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1864103\n");
-    end
-    x = 64'hB7F8BB8D71BC61CF;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1864717\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hC1EFFFFBFDFFFFFF;
-    z = 64'hC3E00010003FFFFE;
-    ans = 64'hC3E0001000BFFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1865331\n");
-    end
-    x = 64'hBFDFFFFFFFFDFFFF;
-    y = 64'hBFF0000000000000;
-    z = 64'hBFCFFFFE7FFFFFFF;
-    ans = 64'h3FD00000BFFE0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1865945\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hBFB000000FFEFFFF;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1866559\n");
-    end
-    x = 64'hC15FFFFF7FFFFFBF;
-    y = 64'h3FDFFFFFFFFE0004;
-    z = 64'h11EFDFFFFFFF7FFF;
-    ans = 64'hC14FFFFF7FFDFFC3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1867173\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1867787\n");
-    end
-    x = 64'hCF8FFFBFFFFFFFEF;
-    y = 64'h3F3A0774EB65EC56;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'hCEDA0740DC7C157C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1868401\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hC000000000000000;
-    z = 64'hB8AB26A99C3445EA;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1869015\n");
-    end
-    x = 64'h3DF851C97AE489ED;
-    y = 64'h406F7FFFEFFFFFFF;
-    z = 64'h80202003FFFFFFFF;
-    ans = 64'h3E77F08248D01307;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1869629\n");
-    end
-    x = 64'hC3C0001EFFFFFFFF;
-    y = 64'hC000000000000001;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h43D0001F00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1870243\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h401D57E3BE3A6EEF;
-    z = 64'hBFEFFFFFE001FFFF;
-    ans = 64'h403C57E3BF3A5EEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1870857\n");
-    end
-    x = 64'hB20F9FFFFFFFFFFE;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h3FFFFFDFFFFDFFFE;
-    ans = 64'h3FFFFFDFFFFDFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1871471\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hC00FFFFFBFFFFF7F;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC350000000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1872085\n");
-    end
-    x = 64'hBFEFFF9FFFFFFFFE;
-    y = 64'hA62000003FFFF000;
-    z = 64'h47EFE0007FFFFFFF;
-    ans = 64'h47EFE0007FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1872699\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hC010000000000001;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1873313\n");
-    end
-    x = 64'hC010000003FBFFFE;
-    y = 64'h403FFFFFFF0007FF;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'hC05FC00006F807FB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1873927\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hC8DF00000001FFFF;
-    ans = 64'hC8DF00000001FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1874541\n");
-    end
-    x = 64'hC297CC5006358D3A;
-    y = 64'hC08AE04A81A830FF;
-    z = 64'h7FDFFF6FFFFFFFFF;
-    ans = 64'h7FDFFF6FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1875155\n");
-    end
-    x = 64'h3811FFFFFFFFFFEF;
-    y = 64'hC340000000000000;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hBB61FFFFFFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1875769\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hC030100FFFFFFFFF;
-    z = 64'h3EC0007FFFFFFFFF;
-    ans = 64'hC050100FF7FFBFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1876383\n");
-    end
-    x = 64'h3FE001FFFDFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h3DE0020000800000;
-    ans = 64'hC34001FFFDFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1876997\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h43CEFFFFFFFFFFFB;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'h43EEFFFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1877611\n");
-    end
-    x = 64'hFFF0000400000800;
-    y = 64'h41D4297AAC5A616A;
-    z = 64'h403FFFFFF003FFFE;
-    ans = 64'hFFF8000400000800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1878225\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hFFE0000000000000;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1878839\n");
-    end
-    x = 64'h0000000FFFFFF800;
-    y = 64'h0740000001000000;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1879453\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hFFE0000000000001;
-    z = 64'hBE4F470F822B383A;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1880067\n");
-    end
-    x = 64'hC3D4000FFFFFFFFF;
-    y = 64'hC800000000003FFC;
-    z = 64'h3EF3FFFFFF7FFFFF;
-    ans = 64'h4BE4001000004FFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1880681\n");
-    end
-    x = 64'h00003FEFFFFFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h8000000000000000;
-    ans = 64'hBFAFF7FFFFFFFF7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1881295\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h3FCFFFFFFBFFFF7F;
-    z = 64'h58B4207C1CD84EB1;
-    ans = 64'h58B4207C1CD84EB1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1881909\n");
-    end
-    x = 64'h802EA50D4C6B8C19;
-    y = 64'hFFF0000000000001;
-    z = 64'hBCAFAF3CE171A7BD;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1882523\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'h47FFFFFFC0000010;
-    z = 64'hC010000000000000;
-    ans = 64'h481FFFFFC000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1883137\n");
-    end
-    x = 64'h37A0020000080000;
-    y = 64'h4CEFFFFFFFFFFFAE;
-    z = 64'hFFF010003FFFFFFF;
-    ans = 64'hFFF810003FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1883751\n");
-    end
-    x = 64'h400FFFFFFFFFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h4340000000000000;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1884365\n");
-    end
-    x = 64'h2943FFFFF8000000;
-    y = 64'hC7F0000003FEFFFF;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1884979\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h0000000000000000;
-    z = 64'h3F80800000000000;
-    ans = 64'h3F80800000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1885593\n");
-    end
-    x = 64'hFFFFFFFFFF000007;
-    y = 64'hB7FFE00000000000;
-    z = 64'hBFF00007FFFFBFFF;
-    ans = 64'hFFFFFFFFFF000007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1886207\n");
-    end
-    x = 64'h413EFFFFFFFFEFFE;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1886821\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h4013531A0FBE0E92;
-    z = 64'hFFEE5ACB0C27A0DC;
-    ans = 64'hFFEE5ACB0C27A0DC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1887435\n");
-    end
-    x = 64'h2A00000200001FFE;
-    y = 64'h0010000000000000;
-    z = 64'h3FEFFFFEFFFDFFFE;
-    ans = 64'h3FEFFFFEFFFDFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1888049\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hC1C1FFFFFFFFFC00;
-    z = 64'hC000000000000001;
-    ans = 64'hC1E20000003FFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1888663\n");
-    end
-    x = 64'h51A66E092B01479D;
-    y = 64'h3FCFFFFFFFFFFFBF;
-    z = 64'hC35FFFBFFFFFFFBE;
-    ans = 64'h51866E092B01476F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1889277\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1889891\n");
-    end
-    x = 64'h43EFFFFFFEFFFF7E;
-    y = 64'hB7FFFFFFFFFFFFF1;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFC0000001FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1890505\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h400FC00000000080;
-    ans = 64'h400FC00000000080;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1891119\n");
-    end
-    x = 64'h43D00101FFFFFFFF;
-    y = 64'hBFEFFFFFFFFEFFFE;
-    z = 64'h40D2B76E9D285754;
-    ans = 64'hC3D00101FFFF7FE3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1891733\n");
-    end
-    x = 64'hBFFFFFFFFFFFEFFD;
-    y = 64'h3CA0000000000001;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1892347\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hC3F0040000010000;
-    z = 64'hC7F0002010000000;
-    ans = 64'hC7F0002010000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1892961\n");
-    end
-    x = 64'h9510000000000000;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hDD7FFFFFFFFFF007;
-    ans = 64'hDD7FFFFFFFFFF007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1893575\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h42F00400000001FE;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'h43100400000001F5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1894189\n");
-    end
-    x = 64'h403FFFFFFFFFC3FE;
-    y = 64'hFFF0000000003FF0;
-    z = 64'hE96D57E9AF40FC9D;
-    ans = 64'hFFF8000000003FF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1894803\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h3FD0000000000001;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h4013FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1895417\n");
-    end
-    x = 64'hBFC000DFFFFFFFFE;
-    y = 64'hBFF1FFFFFF800000;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h3FC200FBFF7FF8FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1896031\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h3F03FFFBFFFFFFFF;
-    ans = 64'h40000013FFFBFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1896645\n");
-    end
-    x = 64'h4020000FFFDFFFFE;
-    y = 64'h7FFFFFFFFBFFFFFC;
-    z = 64'h002FFEFFDFFFFFFF;
-    ans = 64'h7FFFFFFFFBFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1897259\n");
-    end
-    x = 64'hBEBEB67F33381F86;
-    y = 64'h3FE0000000000000;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1897873\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hC3D000000003DFFE;
-    z = 64'hC07FFFFFFFFFBFF7;
-    ans = 64'hC3F000000003DFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1898487\n");
-    end
-    x = 64'h3FCF000400000000;
-    y = 64'h3FE0000000000001;
-    z = 64'hC00E1F43407F411C;
-    ans = 64'hC00D2743207F411C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1899101\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h4030000007EFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h404F80000FDFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1899715\n");
-    end
-    x = 64'h434E104364E5057E;
-    y = 64'h43D7FEFFFFFFFFFF;
-    z = 64'h434008000000007F;
-    ans = 64'h47368B4209909CF5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1900329\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h3FF0000000000000;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h4017FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1900943\n");
-    end
-    x = 64'h5DF54479F7781AF7;
-    y = 64'h4800000101FFFFFF;
-    z = 64'h0010000000000000;
-    ans = 64'h6605447B4E6849AC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1901557\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h3FF0000000000001;
-    z = 64'hC02FFFFFFFFE3FFF;
-    ans = 64'hC027FFFFFFFE3FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1902171\n");
-    end
-    x = 64'h38065F9B291FB446;
-    y = 64'hBC900000007FFFFB;
-    z = 64'h43403FFFFFFFFF7E;
-    ans = 64'h43403FFFFFFFFF7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1902785\n");
-    end
-    x = 64'hC2AB3D1F5ECB8B72;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h4340000000000000;
-    ans = 64'h433FE4C2E0A13475;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1903399\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h1830100100000000;
-    z = 64'h43F00000001FFEFE;
-    ans = 64'h43F00000001FFEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1904013\n");
-    end
-    x = 64'hC1E0000000000500;
-    y = 64'h4000000000000000;
-    z = 64'hC030FFFFFFFF7FFE;
-    ans = 64'hC1F0000001100500;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1904627\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hBFFCEF01E4D5C217;
-    z = 64'hBFE0000000000000;
-    ans = 64'hC01EEF01E4D5C215;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1905241\n");
-    end
-    x = 64'h400D5F58DE8CF296;
-    y = 64'hBE0F90E6DD0EA8AE;
-    z = 64'hC7FFDF0000000000;
-    ans = 64'hC7FFDF0000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1905855\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h3FF0000000000000;
-    ans = 64'h4030FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1906469\n");
-    end
-    x = 64'hC33BE1FA91CC8BBC;
-    y = 64'h3F65E6B30D9F6D97;
-    z = 64'h0000000000000001;
-    ans = 64'hC2B31550AC96818D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1907083\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h4010000000000000;
-    z = 64'hBDEF7FEFFFFFFFFF;
-    ans = 64'h402FFFFFFFFE07FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1907697\n");
-    end
-    x = 64'h3EB0000000001DFF;
-    y = 64'hBFC0DE4738EB51D2;
-    z = 64'h4A0252BE25281E63;
-    ans = 64'h4A0252BE25281E63;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1908311\n");
-    end
-    x = 64'h380FFFFFFFC04000;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1908925\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hBFBFFFFFFDFFFFFC;
-    z = 64'hC00FBFDFFFFFFFFF;
-    ans = 64'hC011DFEFFFDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1909539\n");
-    end
-    x = 64'h80000002FFFFFFFE;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hC03FFFFFFFFFFF01;
-    ans = 64'hC03FFFFFFFFFFF01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1910153\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hBCADDF0E689DB01C;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFD0000000000010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1910767\n");
-    end
-    x = 64'h4000000FFFFFFEFF;
-    y = 64'hBBD00000000023FF;
-    z = 64'hBACFFFFFFF1FFFFF;
-    ans = 64'hBBE00018000022C6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1911381\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h3FE0000000000001;
-    ans = 64'h436FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1911995\n");
-    end
-    x = 64'h40CF800400000000;
-    y = 64'h403DD0FF2D97574A;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1912609\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hBFD3FFFFF0000000;
-    ans = 64'h436FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1913223\n");
-    end
-    x = 64'hA93000000FBFFFFE;
-    y = 64'h383000006FFFFFFF;
-    z = 64'h3F2FFFEFBFFFFFFE;
-    ans = 64'h3F2FFFEFBFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1913837\n");
-    end
-    x = 64'hC340000000000028;
-    y = 64'h7FE0000000000001;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1914451\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h3FF67E8BCE4F5BD6;
-    z = 64'h3FDFFFFFFFFFFFEE;
-    ans = 64'h40187E8BCE4F5BD3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1915065\n");
-    end
-    x = 64'h39DFFFFFFFFFBEFE;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hA29FFFFFFEFFF7FF;
-    ans = 64'h79DFFFFFFFFFBEFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1915679\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h3FA00000FFBFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'h3FC00000FFBFFFF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1916293\n");
-    end
-    x = 64'hB9AFFFFFFEFFFFFD;
-    y = 64'hC03FFFFF7FFFFBFF;
-    z = 64'hC00FFFFFFFFC003E;
-    ans = 64'hC00FFFFFFFFC003E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1916907\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h7FF0000000000001;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1917521\n");
-    end
-    x = 64'h43F6C523A35243F7;
-    y = 64'hC7FFFDF7FFFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1918135\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h47E0000000007FF7;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1918749\n");
-    end
-    x = 64'hBCA003FFFFFFFFFA;
-    y = 64'hC3F000041FFFFFFF;
-    z = 64'h04EFFFFFFF1FFFFF;
-    ans = 64'h40A004042107FFF9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1919363\n");
-    end
-    x = 64'hBFD006FFFFFFFFFE;
-    y = 64'h8000000000000000;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1919977\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h381FFFF8FFFFFFFF;
-    z = 64'hBEFFFFFFF7FFDFFF;
-    ans = 64'hBEFFFFFFF7FFDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1920591\n");
-    end
-    x = 64'hC3DF0BF692B6C42C;
-    y = 64'h8000000000000001;
-    z = 64'hC137FFFF7FFFFFFF;
-    ans = 64'hC137FFFF7FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1921205\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h8028F6B357E9B943;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h804CF6B357E9B941;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1921819\n");
-    end
-    x = 64'h44AFFFFFFFFFC03E;
-    y = 64'h49FFFFC000000007;
-    z = 64'hC3FFFF0001FFFFFF;
-    ans = 64'h4EBFFFBFFFFFC045;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1922433\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h8010000000000000;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1923047\n");
-    end
-    x = 64'hC7AFFFFFFFFFFFFE;
-    y = 64'h76F6258C5D59960D;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE00002C4B18BAB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1923661\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h8010000000000001;
-    z = 64'h5360000005FFFFFF;
-    ans = 64'h5360000005FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1924275\n");
-    end
-    x = 64'h3FF000000007EFFF;
-    y = 64'hBFCFFFFFFFFFFDF8;
-    z = 64'h002BFEFFFFFFFFFE;
-    ans = 64'hBFD000000007EEFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1924889\n");
-    end
-    x = 64'h3F6CE728121A019E;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1925503\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h4F7000007BFFFFFF;
-    z = 64'h7FEFFBFFFFFFFFFF;
-    ans = 64'h7FEFFBFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1926117\n");
-    end
-    x = 64'hBFDEFFFFFFFEFFFF;
-    y = 64'hBCA0000000000000;
-    z = 64'hC7E0000001FF0000;
-    ans = 64'hC7E0000001FF0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1926731\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h422FFFFFFE000FFF;
-    z = 64'h8010000000000000;
-    ans = 64'h424FFFFFFE000FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1927345\n");
-    end
-    x = 64'h801004FFFFFFFFFF;
-    y = 64'hC0109335F5BD73BA;
-    z = 64'hC01624D57E096811;
-    ans = 64'hC01624D57E096811;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1927959\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h3CA0000000000000;
-    ans = 64'hBCCBFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1928573\n");
-    end
-    x = 64'h0000E00000000000;
-    y = 64'h38020000FFFFFFFF;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1929187\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hBFD0000000000000;
-    z = 64'h41FA150B29B47F8E;
-    ans = 64'h41FA150B29A47F8E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1929801\n");
-    end
-    x = 64'h401D1E0FEB280043;
-    y = 64'h41F00002000003FF;
-    z = 64'h3CA3E11D80E9DCED;
-    ans = 64'h421D1E138EEA04EE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1930415\n");
-    end
-    x = 64'hBF2FFFFFFFFFFE7F;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FE0010000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1931029\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hB81F000040000000;
-    z = 64'hE5700000200000FF;
-    ans = 64'hE5700000200000FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1931643\n");
-    end
-    x = 64'hC80FF800000001FF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h801FFFFF7DFFFFFE;
-    ans = 64'h47FFF800000001FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1932257\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hC0203DFFFFFFFFFE;
-    z = 64'h8000000000000001;
-    ans = 64'hC0403DFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1932871\n");
-    end
-    x = 64'h41EFFFE00001FFFF;
-    y = 64'h3FFE631C2D8E143B;
-    z = 64'hD771DCDE9F9BCCFF;
-    ans = 64'hD771DCDE9F9BCCFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1933485\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h0010000000000001;
-    ans = 64'hC00FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1934099\n");
-    end
-    x = 64'hF55000017FFFFFFF;
-    y = 64'hB34000000000005F;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'h68A000018000005E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1934713\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h47E0000000003DFE;
-    ans = 64'h47E0000000003DFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1935327\n");
-    end
-    x = 64'hC1FFFFFEFF000000;
-    y = 64'hBF2FFFE00000001E;
-    z = 64'h3BC6EBA2A1E6E450;
-    ans = 64'h413FFFDEFF01011E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1935941\n");
-    end
-    x = 64'h469FFF7FFDFFFFFE;
-    y = 64'hBFF0000000000001;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'hC69FFF7FFE000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1936555\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hC273FFFFEFFFFFFF;
-    z = 64'h802000000000003B;
-    ans = 64'hC293FFFFEFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1937169\n");
-    end
-    x = 64'h43F0003FFDFFFFFE;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hC1E0004001FFFFFE;
-    ans = 64'hC400003FFE04000E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1937783\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h3F8F00001FFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1938397\n");
-    end
-    x = 64'h3B90004000007FFF;
-    y = 64'h3800AF970246D475;
-    z = 64'h402FFFFFFFFF7FFF;
-    ans = 64'h402FFFFFFFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1939011\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hC000000000000001;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hC020000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1939625\n");
-    end
-    x = 64'hC1E007FFFFFFFFFB;
-    y = 64'hBA8FFFFFFFFFB7FE;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1940239\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h37F001FFFFFFC000;
-    ans = 64'hC02FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1940853\n");
-    end
-    x = 64'hBF78000000001FFF;
-    y = 64'hC02FFFFFFF002000;
-    z = 64'h3DE0003FFFFFFFDF;
-    ans = 64'h3FB7FFFFFFC039FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1941467\n");
-    end
-    x = 64'hB7FDFFFEFFFFFFFF;
-    y = 64'hC010000000000000;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1942081\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hBFD000000007FEFF;
-    z = 64'hC7F0027FFFFFFFFE;
-    ans = 64'hC7F0027FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1942695\n");
-    end
-    x = 64'h3AA04BBDD77BA617;
-    y = 64'hC010000000000001;
-    z = 64'hC63FFFC080000000;
-    ans = 64'hC63FFFC080000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1943309\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hBFDD72EABA1C3A92;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1943923\n");
-    end
-    x = 64'hC1C0000800000000;
-    y = 64'h394CF5E001AE5770;
-    z = 64'h3F995E945329308C;
-    ans = 64'h3F995E945329308C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1944537\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1945151\n");
-    end
-    x = 64'hC80FFFFFFFFF8001;
-    y = 64'hC08E5FDC6EBD366B;
-    z = 64'hC000000000000000;
-    ans = 64'h48AE5FDC6EBCBCED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1945765\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hC340000000000001;
-    z = 64'hC00C0A216E3AA7B1;
-    ans = 64'hC360000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1946379\n");
-    end
-    x = 64'hBE044E11C9371D80;
-    y = 64'hFFDFFFDFFFFFEFFE;
-    z = 64'h3D90080000001FFF;
-    ans = 64'h7DF44DFD7B254A21;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1946993\n");
-    end
-    x = 64'h3FBF7FFFFFFFEFFF;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h3CA0000000000000;
-    ans = 64'hC31F7FFFFFFFEFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1947607\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hBFB07DFFFFFFFFFE;
-    z = 64'h47FFFFFFC000007E;
-    ans = 64'h47FFFFFFC000007E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1948221\n");
-    end
-    x = 64'hA62FFFFFFFFE7FFF;
-    y = 64'hFFE0000000000000;
-    z = 64'h3AFADEEE30BF7D81;
-    ans = 64'h661FFFFFFFFE7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1948835\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h9550004002000000;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1949449\n");
-    end
-    x = 64'hFFD0FFF7FFFFFFFF;
-    y = 64'hC0000F0000000000;
-    z = 64'hC3D0002000000007;
-    ans = 64'h7FE10FE7F87FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1950063\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1950677\n");
-    end
-    x = 64'h37E0040000008000;
-    y = 64'hBE754C8CB9F3E700;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1951291\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'hFFF0000000000000;
-    z = 64'h47F00000000021FF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1951905\n");
-    end
-    x = 64'hBF2CF0D56A2750C2;
-    y = 64'h40F00FFFF0000000;
-    z = 64'h002C00000000FFFF;
-    ans = 64'hC02D0DC622A0A2A9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1952519\n");
-    end
-    x = 64'hBC5FFFFFF8003FFF;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h0010000000000001;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1953133\n");
-    end
-    x = 64'h400FFFFFFFFFFFFE;
-    y = 64'h41E00FFFFFFFFFFE;
-    z = 64'hB57FFFFE00000007;
-    ans = 64'h42000FFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1953747\n");
-    end
-    x = 64'h402E953198585D54;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hC34CD17866F2D756;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1954361\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h41F00000FFFFFF00;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000200002001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1954975\n");
-    end
-    x = 64'hC010472174A39022;
-    y = 64'h9B200000001FFF7F;
-    z = 64'h41F0000080000001;
-    ans = 64'h41F0000080000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1955589\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h0000000000000001;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1956203\n");
-    end
-    x = 64'hC1FFFFFFFFC0000F;
-    y = 64'h41E4000000000007;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hC3F3FFFFFFD80010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1956817\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'hC020004000000001;
-    ans = 64'hC020004000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1957431\n");
-    end
-    x = 64'h7FDFFFEFFFFFBFFF;
-    y = 64'h37EFFFFF7FFF7FFF;
-    z = 64'h42F000000200FFFF;
-    ans = 64'h77DFFFEF7FFF7FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1958045\n");
-    end
-    x = 64'h48008001FFFFFFFF;
-    y = 64'h0010000000000001;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h0820800200000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1958659\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h40468E0D5311E76B;
-    z = 64'h7FD8AF397CA73FA4;
-    ans = 64'h7FD8AF397CA73FA4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1959273\n");
-    end
-    x = 64'hC7E3D9A5109F2CE8;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hE52E363441B31C17;
-    ans = 64'hE52E363441B31C17;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1959887\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h49CF80000000007E;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h49EF80000000007E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1960501\n");
-    end
-    x = 64'h3F807FFFEFFFFFFE;
-    y = 64'hBFD000077FFFFFFF;
-    z = 64'hC362000010000000;
-    ans = 64'hC362000010000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1961115\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h3CA0000000000000;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1961729\n");
-    end
-    x = 64'h3FB003DFFFFFFFFF;
-    y = 64'h06281763EC9DF0B9;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1962343\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h7FF0020000008000;
-    ans = 64'h7FF8020000008000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1962957\n");
-    end
-    x = 64'hBFDFFC0003FFFFFE;
-    y = 64'h39704000001FFFFE;
-    z = 64'hC3CFFFFFFFFFF806;
-    ans = 64'hC3CFFFFFFFFFF806;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1963571\n");
-    end
-    x = 64'hC03000007C000000;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1964185\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h3FD000000000020F;
-    z = 64'hC054CD982D004994;
-    ans = 64'hC0548D982D00498C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1964799\n");
-    end
-    x = 64'hBD27E1AD5D2B709B;
-    y = 64'h3FD0000000000001;
-    z = 64'hC7F0000000002000;
-    ans = 64'hC7F0000000002000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1965413\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hFFDFE0000FFFFFFF;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1966027\n");
-    end
-    x = 64'h40137F75FC3315AF;
-    y = 64'hBFD080000001FFFF;
-    z = 64'hBCAFBFFFFFFFFFFF;
-    ans = 64'hBFF41B71AC171E4B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1966641\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC017FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1967255\n");
-    end
-    x = 64'hBFC000000080FFFF;
-    y = 64'h7FDFFFFF7FFFFEFE;
-    z = 64'hBFD0000000000000;
-    ans = 64'hFFAFFFFF8101FEF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1967869\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h3FE0000000000001;
-    z = 64'hC7E00000407FFFFF;
-    ans = 64'hC7E00000407FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1968483\n");
-    end
-    x = 64'hBFAC2BA02D28C36A;
-    y = 64'h800010000000FFFE;
-    z = 64'h43C0000020004000;
-    ans = 64'h43C0000020004000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1969097\n");
-    end
-    x = 64'h437A753665F4C413;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1969711\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h7FEFFFF801FFFFFF;
-    z = 64'h4035D7EF299EB91C;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1970325\n");
-    end
-    x = 64'hC8007FFFFFFFFFF7;
-    y = 64'h3FF0000000000000;
-    z = 64'h41E0000200000FFE;
-    ans = 64'hC8007FFFFFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1970939\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h37E00000001FFDFE;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1971553\n");
-    end
-    x = 64'h800BFFFBFFFFFFFF;
-    y = 64'h452FFBFFDFFFFFFE;
-    z = 64'h1A5000000001FF80;
-    ans = 64'h1A5000000001FF80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1972167\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hC010000000000000;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1972781\n");
-    end
-    x = 64'hC480000100000001;
-    y = 64'hC06FFFFFE0100000;
-    z = 64'hBCA0000000000001;
-    ans = 64'h45000000F007FF01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1973395\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h4000000000000000;
-    z = 64'hC01FFFFFFFC007FF;
-    ans = 64'h3E2FFC0080000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1974009\n");
-    end
-    x = 64'hC16FFFFFDFFFFF7E;
-    y = 64'h3DB1201419E58E36;
-    z = 64'h4E1FDFFFFFFFFFFC;
-    ans = 64'h4E1FDFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1974623\n");
-    end
-    x = 64'hDF50011FFFFFFFFE;
-    y = 64'h4000000000000001;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1975237\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h47E003FFFFFFFFBF;
-    z = 64'hC01FFF0000001FFF;
-    ans = 64'h480003FFFFFFFFBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1975851\n");
-    end
-    x = 64'h402862D346BAA1CA;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h411FFFFFFFFBFEFF;
-    ans = 64'h412000618B4B1A6A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1976465\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h380FFFFFEFFFF7FE;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1977079\n");
-    end
-    x = 64'hBEFEEFFFFFFFFFFF;
-    y = 64'h7FF000003BFFFFFE;
-    z = 64'h40CF7B1D7B973928;
-    ans = 64'h7FF800003BFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1977693\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h4010000000000001;
-    z = 64'hC000000000000001;
-    ans = 64'h402C000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1978307\n");
-    end
-    x = 64'h3FB2000000000001;
-    y = 64'hC035E13C67919490;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'hBFF89D63F483C723;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1978921\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h3FE92BD129459E10;
-    ans = 64'h404064AF44A51677;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1979535\n");
-    end
-    x = 64'h3CA1FDFFFFFFFFFF;
-    y = 64'hB9FC538ED462F3E6;
-    z = 64'h480FFC000000003E;
-    ans = 64'h480FFC000000003E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1980149\n");
-    end
-    x = 64'hBFB0E2E2A19DE3CA;
-    y = 64'h4340000000000000;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC3508717150CEF1E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1980763\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hB80FFFF80000000F;
-    z = 64'hC1CFFFFFFFFFFE08;
-    ans = 64'hC1CFFFFFFFFFFE08;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1981377\n");
-    end
-    x = 64'h3FBFFFFFFFFFFFC2;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h462FFFC0007FFFFF;
-    ans = 64'h462FFFC00080000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1981991\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hC80FE0001FFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'hC82FE0001FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1982605\n");
-    end
-    x = 64'h37F0001FFFFC0000;
-    y = 64'hC000000800000020;
-    z = 64'h3FBFFFF800002000;
-    ans = 64'h3FBFFFF800002000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1983219\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h7FE0000000000000;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1983833\n");
-    end
-    x = 64'h41E8BF333C53DC11;
-    y = 64'hBFFFE02000000000;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hC1F8A68CC84AC489;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1984447\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hC3FFFBFFF8000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1985061\n");
-    end
-    x = 64'h3FC002FFFFFFFFFE;
-    y = 64'h480FFFFFFFFEFFFE;
-    z = 64'h884FDFFFFFFFFFFF;
-    ans = 64'h47E002FFFFFF7FE5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1985675\n");
-    end
-    x = 64'hC150000001FFFFEF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1986289\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h3FDFE0000000000F;
-    z = 64'h381000800007FFFF;
-    ans = 64'h3FFFE0000000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1986903\n");
-    end
-    x = 64'h61CFFFC000007FFF;
-    y = 64'h7FF0000000000001;
-    z = 64'h37EF040000000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1987517\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hBFBFFFFFFC00000F;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3E2FFFFF78000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1988131\n");
-    end
-    x = 64'hB815F9F97A094A5C;
-    y = 64'h43FEFFFFFFF7FFFF;
-    z = 64'h43CFFFFFFF7FFFFD;
-    ans = 64'h43CFFFFFFF7FFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1988745\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1989359\n");
-    end
-    x = 64'h800000000003FFFE;
-    y = 64'h578284B14DFCC6E4;
-    z = 64'h8000000000000000;
-    ans = 64'h958284A80BA41FE6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1989973\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h8000000000000001;
-    z = 64'h3D00001000000020;
-    ans = 64'h3D00001000000020;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1990587\n");
-    end
-    x = 64'h002FFC0000001FFE;
-    y = 64'h4820040000000003;
-    z = 64'h401E4B4C703F7797;
-    ans = 64'h401E4B4C703F7797;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1991201\n");
-    end
-    x = 64'hFFF090069ECD0983;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hC010000000000000;
-    ans = 64'hFFF890069ECD0983;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1991815\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h802FFE0100000000;
-    z = 64'h266FFFFFFBC00000;
-    ans = 64'h266FFFFFFBC00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1992429\n");
-    end
-    x = 64'h2F9A42B08462C128;
-    y = 64'h8010000000000000;
-    z = 64'hC800004001FFFFFF;
-    ans = 64'hC800004001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1993043\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h7FDFFFFBFEFFFFFF;
-    z = 64'h3FD0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1993657\n");
-    end
-    x = 64'hC27BDFFFFFFFFFFF;
-    y = 64'hBFD415B58CED442A;
-    z = 64'hC3F657E5A2C1DB31;
-    ans = 64'hC3F657E59A02669E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1994271\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1994885\n");
-    end
-    x = 64'h801000000000005F;
-    y = 64'h3FEE0000000000FF;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1995499\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hBCA0000000000000;
-    z = 64'h40D0001010000000;
-    ans = 64'h40D0001010000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1996113\n");
-    end
-    x = 64'hC7A95C960A5C58BF;
-    y = 64'h404000FFFFFDFFFF;
-    z = 64'hC7F58C9EBE2500D7;
-    ans = 64'hC807756548EF69E4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1996727\n");
-    end
-    x = 64'h403FFFC003FFFFFE;
-    y = 64'hBCA0000000000001;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000009;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1997341\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h801020000FFFFFFF;
-    z = 64'hBFE00000081FFFFF;
-    ans = 64'hBFE00000081FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1997955\n");
-    end
-    x = 64'h8010000017FFFFFE;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h37EEFFFFFFFFFFFA;
-    ans = 64'h37EEFFFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1998569\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hC3F8AC97F983EA17;
-    z = 64'h3CA0000000000001;
-    ans = 64'hC418AC97F983EA17;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1999183\n");
-    end
-    x = 64'h3F6FFDFFFFFFFF7F;
-    y = 64'hC03A51B5C97AF6EB;
-    z = 64'hC000000010000FFF;
-    ans = 64'hC000D280957102F6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"1999797\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hBFD0000000000001;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFF4000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2000411\n");
-    end
-    x = 64'h3F4FFFBFFFFFFFFF;
-    y = 64'hBFC00001FFFFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2001025\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h3FB0003FFFFFFFDF;
-    ans = 64'hBFFEFFFC00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2001639\n");
-    end
-    x = 64'h67CC0B0B8FFD1579;
-    y = 64'hC1F9F508DABEAAB9;
-    z = 64'h37FFFFFFFFFFE00F;
-    ans = 64'hE9D6BF5D5B795C69;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2002253\n");
-    end
-    x = 64'hC3E40000001FFFFE;
-    y = 64'hBFE0000000000000;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'h43D40000001FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2002867\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hC91FFFFFFFFFC001;
-    z = 64'hBF8FE00040000000;
-    ans = 64'hC93FFFFFFFFFC001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2003481\n");
-    end
-    x = 64'h338FFFFDFFDFFFFF;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h43E0200800000000;
-    ans = 64'h43E0200800000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2004095\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h3F5FFFFFFFD80000;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h3F7FFFFFFFD80000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2004709\n");
-    end
-    x = 64'hE96FFFFEFF7FFFFF;
-    y = 64'h3FF1FFFFBFFFFFFE;
-    z = 64'hBFCFFFF800000040;
-    ans = 64'hE971FFFF2FB801FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2005323\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hBFF0000000000000;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2005937\n");
-    end
-    x = 64'h3D200007FFFFFFEF;
-    y = 64'hC00876C4B616918C;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2006551\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hCFA4200000000000;
-    ans = 64'hCFA4200000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2007165\n");
-    end
-    x = 64'hA60FC80000000000;
-    y = 64'hFFE107FFFFFFFFFF;
-    z = 64'hFFDFFFC800000000;
-    ans = 64'hFFDFFFC800000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2007779\n");
-    end
-    x = 64'hC180001FFFFFE000;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h4190001FFBFFDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2008393\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h401389E4A0774013;
-    z = 64'h47F00003FFFDFFFF;
-    ans = 64'h47F00003FFFDFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2009007\n");
-    end
-    x = 64'hB7E4A4C01BE0366D;
-    y = 64'hC000000000000001;
-    z = 64'h4030040000000000;
-    ans = 64'h4030040000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2009621\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h3DD822906B7C1856;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h3DF822906B7C1856;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2010235\n");
-    end
-    x = 64'hBF300003FFFFFFFA;
-    y = 64'h4663B7CF95147D4D;
-    z = 64'hC020000FFFFFDFFF;
-    ans = 64'hC5A3B7D48308628B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2010849\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'hC02FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2011463\n");
-    end
-    x = 64'h480F803FFFFFFFFF;
-    y = 64'hFFD01FFFFFFFFFC0;
-    z = 64'h4340000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2012077\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hC010000000000001;
-    z = 64'hBFAA9630F7FA91E2;
-    ans = 64'hC0300D4B187BFD4A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2012691\n");
-    end
-    x = 64'h46BFFFFFFFFBE000;
-    y = 64'hFFDFFFFFFFE00020;
-    z = 64'h001D7B4EBB1E2287;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2013305\n");
-    end
-    x = 64'hBFDFFFFFFC000400;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hBFE0000000000000;
-    ans = 64'h400BFFFFFC0003FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2013919\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h65E6E9986A054481;
-    z = 64'h3FC0017FFFFFFFFE;
-    ans = 64'h6606E9986A054481;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2014533\n");
-    end
-    x = 64'h400FFFFFFF7BFFFE;
-    y = 64'hC340000000000000;
-    z = 64'hBFF0800000000010;
-    ans = 64'hC35FFFFFFF7BFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2015147\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hBFDFFFFFFFF02000;
-    z = 64'h0000000000000000;
-    ans = 64'hBFFFFFFFFFF02000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2015761\n");
-    end
-    x = 64'hB8E0004080000000;
-    y = 64'hC1E007FFFFFFEFFF;
-    z = 64'hC1F04C3464638FD0;
-    ans = 64'hC1F04C3464638FD0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2016375\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h8010000000000000;
-    ans = 64'hC36FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2016989\n");
-    end
-    x = 64'h2F1F7FF800000000;
-    y = 64'h3FA5BD663D679381;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2017603\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hFFE0000000000000;
-    z = 64'hC95FFFEFFFFDFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2018217\n");
-    end
-    x = 64'hBFDEFFFFFF000000;
-    y = 64'h002FFFFFFFFC3FFE;
-    z = 64'h0000002003FFFFFE;
-    ans = 64'h801EFFDFFAFC5E00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2018831\n");
-    end
-    x = 64'h3FC0000000000021;
-    y = 64'hFFE0000000000001;
-    z = 64'hBFD0000000000001;
-    ans = 64'hFFB0000000000022;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2019445\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'h7FD000011FFFFFFE;
-    z = 64'h480A9FA0EAF588F8;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2020059\n");
-    end
-    x = 64'h7FFFE00000100000;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hC05FFFFFFFFFFF0F;
-    ans = 64'h7FFFE00000100000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2020673\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hBFB4E50445E15FFE;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2021287\n");
-    end
-    x = 64'hC34FFFFFF80007FE;
-    y = 64'h43D0047FFFFFFFFF;
-    z = 64'h41C87C353CDA6D3F;
-    ans = 64'hC730047FFBFEE3FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2021901\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hFFF0000000000001;
-    z = 64'h8000000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2022515\n");
-    end
-    x = 64'h578E007FFFFFFFFF;
-    y = 64'hC3CFFE7FFFFFFFFE;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'hDB6DFF17F9FFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2023129\n");
-    end
-    x = 64'h4010000000000000;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h7FEFFFFFBFFFFFDE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2023743\n");
-    end
-    x = 64'hC34FFF5FFFFFFFFE;
-    y = 64'hA21403EE84EDAC39;
-    z = 64'hC1EFFFFFEFFFFFFF;
-    ans = 64'hC1EFFFFFEFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2024357\n");
-    end
-    x = 64'hBFDDFFFFFFFFFFF6;
-    y = 64'h0000000000000000;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2024971\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h390400000000FFFE;
-    z = 64'h41CB3043321369C3;
-    ans = 64'h41CB3043321369C3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2025585\n");
-    end
-    x = 64'h37FFFFFFFFFFFFEE;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hBC600010001FFFFF;
-    ans = 64'hBC600010001FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2026199\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hB7F1000000000002;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2026813\n");
-    end
-    x = 64'hFFD3F02B09C09A41;
-    y = 64'hC031200000000000;
-    z = 64'hC34BB5F53BEB70B5;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2027427\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h0010000000000000;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2028041\n");
-    end
-    x = 64'h381FFF801FFFFFFF;
-    y = 64'h43EFFE0007FFFFFE;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2028655\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hBFDFFF0007FFFFFF;
-    ans = 64'hBFDFFF0007FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2029269\n");
-    end
-    x = 64'h40022DF889E0460E;
-    y = 64'h480083FFFFFFFFFF;
-    z = 64'hBFE003FFDFFFFFFF;
-    ans = 64'h4812C3F3CC51C04F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2029883\n");
-    end
-    x = 64'h404FFFFFFF00003E;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h007F7FFFFF00003C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2030497\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h43D000001EFFFFFF;
-    z = 64'hBA736F94D9A1D3B3;
-    ans = 64'h43F000001F000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2031111\n");
-    end
-    x = 64'h3FD00003FFFFFFEF;
-    y = 64'h3CA0000000000001;
-    z = 64'h15407FFFFFFFFF80;
-    ans = 64'h3C800003FFFFFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2031725\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h7FEFFFFF7FFFFEFF;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2032339\n");
-    end
-    x = 64'hC78FFFFFFFF7FEFE;
-    y = 64'hC6C5A9C8AB5EEB18;
-    z = 64'h3F7007FFFFEFFFFF;
-    ans = 64'h4E65A9C8AB597FF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2032953\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2033567\n");
-    end
-    x = 64'h42A000000FFFFF00;
-    y = 64'hBFD3000000000000;
-    z = 64'h3FF0000000000000;
-    ans = 64'hC283000012FFF6D0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2034181\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h3FD0000000000001;
-    z = 64'hBCAFFFFFDFFFEFFE;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2034795\n");
-    end
-    x = 64'h400101E2034348A8;
-    y = 64'h3800000FFFFFC000;
-    z = 64'h801000000000FFFD;
-    ans = 64'h381101F3052507E4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2035409\n");
-    end
-    x = 64'hC3D73FF233226D60;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h8010000000000000;
-    ans = 64'hC3C73FF233226D5F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2036023\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h4331EBC8B95B9247;
-    z = 64'h001F7FFEFFFFFFFF;
-    ans = 64'h4351EBC8B95B9248;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2036637\n");
-    end
-    x = 64'hBDE82DB0311C0CE4;
-    y = 64'h3FE0000000000000;
-    z = 64'hB7F0000003FFFFFB;
-    ans = 64'hBDD82DB0311C0CE4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2037251\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h417FE00000002000;
-    z = 64'hC340000000000000;
-    ans = 64'hC33FFFFFF8080000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2037865\n");
-    end
-    x = 64'h4691FFFBFFFFFFFF;
-    y = 64'h0D0FFFF020000000;
-    z = 64'hC27ABBD29987D6DC;
-    ans = 64'hC27ABBD29987D6DC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2038479\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2039093\n");
-    end
-    x = 64'h43F003FBFFFFFFFE;
-    y = 64'hBFEFF00000007FFF;
-    z = 64'h3FE0000000000001;
-    ans = 64'hC3EFF7F40400801B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2039707\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h407FFFE000FFFFFE;
-    ans = 64'h40801FF0007FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2040321\n");
-    end
-    x = 64'h40CCF306BA45AE38;
-    y = 64'hA6A00000000207FF;
-    z = 64'h7FD1002000000000;
-    ans = 64'h7FD1002000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2040935\n");
-    end
-    x = 64'hBF7FBFFFFFBFFFFE;
-    y = 64'h3FF0000000000001;
-    z = 64'h8000000000000001;
-    ans = 64'hBF7FBFFFFFC00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2041549\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h402828229504FC88;
-    z = 64'hFFD5A537DFEEA9A8;
-    ans = 64'hFFD5A537DFEEA9A8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2042163\n");
-    end
-    x = 64'h3C1000000000037F;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h2516ADF118D6B0B6;
-    ans = 64'h3C2000000000037E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2042777\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hBF1FBFFFFFFF7FFF;
-    z = 64'hC010000000000001;
-    ans = 64'hC010007EFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2043391\n");
-    end
-    x = 64'hCC50000000000FBF;
-    y = 64'h3FFFFBFFFEFFFFFE;
-    z = 64'hB7E0008000000006;
-    ans = 64'hCC5FFBFFFF001F78;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2044005\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h4000000000000001;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2044619\n");
-    end
-    x = 64'h5EB0734C2E41E43E;
-    y = 64'hC1F0000000200040;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'hE0B0734C2E62CB18;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2045233\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hCE1000000027FFFF;
-    ans = 64'hCE1000000027FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2045847\n");
-    end
-    x = 64'h802EFFFFFFFFFE00;
-    y = 64'h41EFF0000000001F;
-    z = 64'hBCEFFC0001FFFFFF;
-    ans = 64'hBCEFFC0001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2046461\n");
-    end
-    x = 64'h98700000000001BF;
-    y = 64'h4010000000000000;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2047075\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hD3100000FF000000;
-    z = 64'hBF40000000101FFF;
-    ans = 64'hD3300000FF000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2047689\n");
-    end
-    x = 64'h437F000000002000;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h570FFDFFFFFFFBFE;
-    ans = 64'h570FFDFFFFFFFBFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2048303\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hBC6FFFFF80004000;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2048917\n");
-    end
-    x = 64'hB81E07FFFFFFFFFF;
-    y = 64'h3FEC000007FFFFFE;
-    z = 64'h3C6040000000003E;
-    ans = 64'h3C6040000000003E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2049531\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h4340000000000000;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h4360000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2050145\n");
-    end
-    x = 64'hC0CEF80000000000;
-    y = 64'h4010000401000000;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'hC0EEF807BFEF8000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2050759\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h4340000000000001;
-    z = 64'h3810000000040001;
-    ans = 64'h4360000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2051373\n");
-    end
-    x = 64'h402FFFFFFFF80020;
-    y = 64'hDC5000FFFFFFFFE0;
-    z = 64'hB428005DA0DF19DC;
-    ans = 64'hDC9000FFFFFBFFB0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2051987\n");
-    end
-    x = 64'hBF809DB40C6850A4;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2052601\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h381FFFFFF0080000;
-    z = 64'h7FF7FBFFFFFFFFFF;
-    ans = 64'h7FFFFBFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2053215\n");
-    end
-    x = 64'hBCA01FFFFFFFBFFF;
-    y = 64'h7FE0000000000000;
-    z = 64'h47EE010000000000;
-    ans = 64'hFC901FFFFFFFBFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2053829\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h43F10FFFFFFFFFFE;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'h44110FFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2054443\n");
-    end
-    x = 64'hC3ACF9C2E5A7EDD3;
-    y = 64'hBCA0000000000000;
-    z = 64'h3F2000000001FFDE;
-    ans = 64'h405CF9C4E5A7EDD3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2055057\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2055671\n");
-    end
-    x = 64'hFFF0000004003FFE;
-    y = 64'h6A9FFBFFFFDFFFFF;
-    z = 64'h3CA0000000000000;
-    ans = 64'hFFF8000004003FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2056285\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h7FF0000000000000;
-    z = 64'hC061FFFFFFFFFFFA;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2056899\n");
-    end
-    x = 64'h3FD351BAD190EE0E;
-    y = 64'hFB20103FFFFFFFFF;
-    z = 64'h44FA1AFBC4ECDEF6;
-    ans = 64'hFB036559D34DC53F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2057513\n");
-    end
-    x = 64'h41E000FFFFFFFFF7;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2058127\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h3FF38C1608094E37;
-    z = 64'hB90DFCA930882C14;
-    ans = 64'h40138C1608094E38;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2058741\n");
-    end
-    x = 64'h802FBFF000000000;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h402FFFFFFDFFFF7F;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2059355\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h4036F22DF5763FE7;
-    z = 64'hBFF0000000000000;
-    ans = 64'h4056B22DF5763FE8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2059969\n");
-    end
-    x = 64'h3FF6FE2E918FDD2B;
-    y = 64'hB7E0E00000000000;
-    z = 64'hC02418F02A11FD65;
-    ans = 64'hC02418F02A11FD65;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2060583\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2061197\n");
-    end
-    x = 64'h37EE8DC9DCAE85C1;
-    y = 64'h002001FFFFFFFFFC;
-    z = 64'h0010000000000001;
-    ans = 64'h0010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2061811\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h356FFFFFF8800000;
-    ans = 64'h356FFFFFF8800000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2062425\n");
-    end
-    x = 64'h37F0000000005FFE;
-    y = 64'hB8000005FFFFFFFF;
-    z = 64'h3CE0002004000000;
-    ans = 64'h3CE0002004000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2063039\n");
-    end
-    x = 64'hFFD0000000000000;
-    y = 64'h8010000000000001;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2063653\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hB8100800000003FF;
-    z = 64'hC3E0000004040000;
-    ans = 64'hC3E0000004040000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2064267\n");
-    end
-    x = 64'h43C7FFFBFFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h401DFFFFFFFFFFEF;
-    ans = 64'h401DFFFFFFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2064881\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hB8C0003FFFFFFFFE;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2065495\n");
-    end
-    x = 64'hB80000FFFFFFFFF0;
-    y = 64'h7FF0000800000003;
-    z = 64'h99D7403FC620853D;
-    ans = 64'h7FF8000800000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2066109\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hBCA0000000000001;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2066723\n");
-    end
-    x = 64'hCD872EAD1D5E17B0;
-    y = 64'hC800001FFFFFDFFF;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h55972EDB7AB8240D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2067337\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h3EA0000002000080;
-    ans = 64'h3EA0000001800080;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2067951\n");
-    end
-    x = 64'h4F300013FFFFFFFF;
-    y = 64'hC0BFE34666739635;
-    z = 64'h40372CC2C5156BE3;
-    ans = 64'hCFFFE36E428B9643;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2068565\n");
-    end
-    x = 64'hC5DFFFFFFFFBF800;
-    y = 64'hBFD0000000000000;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h45BFFFFFFFFBF800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2069179\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h703FFFFFFFFC0008;
-    z = 64'hBFF0000007FFFFFF;
-    ans = 64'h705FFFFFFFFC000A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2069793\n");
-    end
-    x = 64'h0020010000000003;
-    y = 64'hBFD0000000000001;
-    z = 64'h41DAD18B4B15E433;
-    ans = 64'h41DAD18B4B15E433;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2070407\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h3FDFFFFBFF000000;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'h3FF7FFFBFF000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2071021\n");
-    end
-    x = 64'hB7FFFFAFFFFFFFFF;
-    y = 64'hBFA0000007FFFBFF;
-    z = 64'hC02FFFFFF8000020;
-    ans = 64'hC02FFFFFF8000020;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2071635\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hBFE0000000000000;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'hBFF0000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2072249\n");
-    end
-    x = 64'h4050000FFFFF8000;
-    y = 64'h3FEFFFFFFFFFFFB7;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2072863\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hBFE0000000000001;
-    z = 64'h58B0023FFFFFFFFF;
-    ans = 64'h58B0023FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2073477\n");
-    end
-    x = 64'hC0D00407FFFFFFFF;
-    y = 64'h44560B21BC8DFFBC;
-    z = 64'h45D000007FFFC000;
-    ans = 64'h45CFF4F8A83A38FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2074091\n");
-    end
-    x = 64'h43CC0000001FFFFF;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'hC3CC0000001FFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2074705\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h001FFFFFEFFFFFF7;
-    z = 64'hE5FFFFFFFFFFFFFE;
-    ans = 64'hE5FFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2075319\n");
-    end
-    x = 64'h3FAFFFDFF7FFFFFE;
-    y = 64'hBFF0000000000000;
-    z = 64'hC1EFFF7FFFDFFFFF;
-    ans = 64'hC1EFFF7FFFE1FFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2075933\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h7FEFDFFFFFF80000;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2076547\n");
-    end
-    x = 64'h3FCF0000000FFFFF;
-    y = 64'hC54BFFFFFFF7FFFE;
-    z = 64'h380FFFFFFFFFFC10;
-    ans = 64'hC52B200000063FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2077161\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'hC01E000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2077775\n");
-    end
-    x = 64'hC34000000FFEFFFE;
-    y = 64'hC000000000000009;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2078389\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hC000000000000000;
-    z = 64'hB810000000040400;
-    ans = 64'hC020000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2079003\n");
-    end
-    x = 64'hCCFFFFC0000FFFFE;
-    y = 64'hC3F11E81095D5E21;
-    z = 64'hBE2FF8000007FFFF;
-    ans = 64'h51011E5ECC63DAA6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2079617\n");
-    end
-    x = 64'hBD4FFFDFDFFFFFFE;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2080231\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h3FB639FC3EC1E7C8;
-    z = 64'h47F1FFFFFFFFF7FF;
-    ans = 64'h47F1FFFFFFFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2080845\n");
-    end
-    x = 64'h37E0000002001FFF;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h41F00007FFFFFFEF;
-    ans = 64'h41F00007FFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2081459\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hBFD0000FBFFFFFFF;
-    z = 64'hBCA0000000000000;
-    ans = 64'hBFF0000FC0000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2082073\n");
-    end
-    x = 64'h3CA0000FFFFFFFEE;
-    y = 64'h0A0FFE0080000000;
-    z = 64'h3FA00000000FFEFF;
-    ans = 64'h3FA00000000FFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2082687\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h3FD0000000000000;
-    ans = 64'hC03FC00000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2083301\n");
-    end
-    x = 64'hC01EDEE0EE02DDAB;
-    y = 64'hC02EAF41CE1BC0BD;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2083915\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hC0EFF6FFFFFFFFFF;
-    ans = 64'hC0EFFAFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2084529\n");
-    end
-    x = 64'h406E5774F05A50D8;
-    y = 64'h002F808000000000;
-    z = 64'h7FF000000200007F;
-    ans = 64'h7FF800000200007F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2085143\n");
-    end
-    x = 64'hC02FFE0000008000;
-    y = 64'hC340000000000001;
-    z = 64'h3FF0000000000001;
-    ans = 64'h437FFE0000008002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2085757\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h401FFE0001FFFFFF;
-    z = 64'h747A807778879FF0;
-    ans = 64'h747A807778879FF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2086371\n");
-    end
-    x = 64'h800000101FFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hC3E29498223D1003;
-    ans = 64'hC3E29498223D1003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2086985\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'h4010000000000407;
-    z = 64'h8010000000000001;
-    ans = 64'h4030000000000408;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2087599\n");
-    end
-    x = 64'hC3D10560432CD7FD;
-    y = 64'h40700000000007FC;
-    z = 64'hBD23FFFBFFFFFFFE;
-    ans = 64'hC4510560432CE07B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2088213\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hFFE0000000000001;
-    z = 64'h3CA0000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2088827\n");
-    end
-    x = 64'hBF4003FFFFDFFFFF;
-    y = 64'h415000003FFFF7FF;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC350000000000200;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2089441\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hB7FFFE00000003FF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2090055\n");
-    end
-    x = 64'h43D00000002FFFFF;
-    y = 64'hBFDFFF000000FFFF;
-    z = 64'hC34FFFFFBFE00000;
-    ans = 64'hC3C01F7FFFF05E7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2090669\n");
-    end
-    x = 64'hC7E0000007FFFFF6;
-    y = 64'hFFF0000000000000;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2091283\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hCD22000000200000;
-    z = 64'hC3DFFFFFFFF7FFFE;
-    ans = 64'hCD42000000200001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2091897\n");
-    end
-    x = 64'hC1C0800003FFFFFF;
-    y = 64'hFFF0000000000001;
-    z = 64'hC1DFFFFFCFFFFFFF;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2092511\n");
-    end
-    x = 64'h4010000000000001;
-    y = 64'hC3A00001FEFFFFFE;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'hC3C00001FEFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2093125\n");
-    end
-    x = 64'h321FFFFFDC000000;
-    y = 64'hC3400000001FEFFF;
-    z = 64'h43EFFFFFDFFEFFFF;
-    ans = 64'h43EFFFFFDFFEFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2093739\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h0000000000000000;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h001FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2094353\n");
-    end
-    x = 64'hC7E7BF896056C7B0;
-    y = 64'hC1FFFFFFFEFBFFFE;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'h49F7BF895F95D372;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2094967\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h0000000000000001;
-    z = 64'h462FFFFFFFFFFFFF;
-    ans = 64'h462FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2095581\n");
-    end
-    x = 64'h802000000007FF7F;
-    y = 64'h7FE0000001FFBFFE;
-    z = 64'h43F1FFFBFFFFFFFE;
-    ans = 64'h43F1FFFBFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2096195\n");
-    end
-    x = 64'h427F5A5B8669FAAB;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2096809\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC3FFFBFFFFFFFFEF;
-    z = 64'hC1D000000000FF7E;
-    ans = 64'hC42FFC0000007FEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2097423\n");
-    end
-    x = 64'h49500000003FFF7E;
-    y = 64'h0010000000000000;
-    z = 64'hC261FFFF7FFFFFFE;
-    ans = 64'hC261FFFF7FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2098037\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC3EA56D05D78BE9F;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2098651\n");
-    end
-    x = 64'hC341FFFFBFFFFFFF;
-    y = 64'h41FC0000007FFFFE;
-    z = 64'hC3F0003FDFFFFFFF;
-    ans = 64'hC54F80001091FEFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2099265\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h0050FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2099879\n");
-    end
-    x = 64'hBD0000000077FFFF;
-    y = 64'hC110000010000080;
-    z = 64'hC010000000000000;
-    ans = 64'hC00FFFFFFFC00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2100493\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h3CA0000000000000;
-    z = 64'h988F384F6949CF89;
-    ans = 64'h3CCFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2101107\n");
-    end
-    x = 64'h480B5B7C936D05AE;
-    y = 64'h41C0000000400FFE;
-    z = 64'hBDA0000008200000;
-    ans = 64'h49DB5B7C93DA8EF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2101721\n");
-    end
-    x = 64'h0BA24ED74A49604E;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2102335\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hBFD001000000001E;
-    z = 64'h381F019FB1D0E921;
-    ans = 64'hC00001000000001D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2102949\n");
-    end
-    x = 64'h434FFFFF77FFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h036FFFDFBFFFFFFF;
-    ans = 64'h400FFFFF77FFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2103563\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h40300000000401FE;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2104177\n");
-    end
-    x = 64'h802FFEDFFFFFFFFF;
-    y = 64'h7FE8008000000000;
-    z = 64'h3E1FFFFFFFF08000;
-    ans = 64'hC027FFA7FB6FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2104791\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h0000000000000000;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2105405\n");
-    end
-    x = 64'hB13FF9FFFFFFFFFF;
-    y = 64'h7FEB577402A3C99B;
-    z = 64'hC000000000000001;
-    ans = 64'hF13B52539CE34AE4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2106019\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hC340000000400002;
-    ans = 64'hC340000000400000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2106633\n");
-    end
-    x = 64'hBEB000000081FFFE;
-    y = 64'h28400200000FFFFE;
-    z = 64'h0006905A4202FB7C;
-    ans = 64'hA70002000092103C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2107247\n");
-    end
-    x = 64'h49BFFFFFFC07FFFF;
-    y = 64'h3FE0000000000001;
-    z = 64'h3CA0000000000001;
-    ans = 64'h49AFFFFFFC080001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2107861\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h4027153765463EB7;
-    z = 64'hBFF0401FFFFFFFFF;
-    ans = 64'h4056D436E5463EB6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2108475\n");
-    end
-    x = 64'hD4B000007FBFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h3FBFFFE000000000;
-    ans = 64'hD4B000007FBFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2109089\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC4D333B83E26FA35;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2109703\n");
-    end
-    x = 64'hDF80000000840000;
-    y = 64'hC0F65C25999F8D14;
-    z = 64'h3CA0080003FFFFFE;
-    ans = 64'h60865C259A58054A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2110317\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h3FF0000000000000;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2110931\n");
-    end
-    x = 64'h802A7CAC07CCC888;
-    y = 64'h3B3FFDFFFFFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2111545\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hB59388B135C6AA9F;
-    ans = 64'h402FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2112159\n");
-    end
-    x = 64'h80200000100000FF;
-    y = 64'hB500000000001000;
-    z = 64'hBFF9A6A59DDDCA4B;
-    ans = 64'hBFF9A6A59DDDCA4B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2112773\n");
-    end
-    x = 64'hC1EFFFFF800007FF;
-    y = 64'h4000000000000000;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'hC1FFFFFF800007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2113387\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h7FDEDBBC8C149E63;
-    z = 64'h3DE00000047FFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2114001\n");
-    end
-    x = 64'hC80FFFFFC0000007;
-    y = 64'h4000000000000001;
-    z = 64'h000F69ED724B3CE0;
-    ans = 64'hC81FFFFFC0000009;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2114615\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h3FA400000003FFFF;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2115229\n");
-    end
-    x = 64'h43D1000000000007;
-    y = 64'h3F80007FF7FFFFFF;
-    z = 64'h43E00000000007F7;
-    ans = 64'h43E0110087F787F7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2115843\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2116457\n");
-    end
-    x = 64'hF0FEFF7FFFFFFFFF;
-    y = 64'h41C00007FFFF8000;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hF2CEFF8F7FBF0803;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2117071\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h4010000000000001;
-    z = 64'hC050FFFFFFFF0000;
-    ans = 64'hC041FFFFFFFE0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2117685\n");
-    end
-    x = 64'hC010D92032C10045;
-    y = 64'h62F00000FFFFFFFF;
-    z = 64'hC01FFC0000000002;
-    ans = 64'hE310D92140530370;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2118299\n");
-    end
-    x = 64'h42FFF00000001000;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h432FF00000000FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2118913\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC34ECB4086F52F1D;
-    z = 64'h4A3FF3FFFFFFFFFE;
-    ans = 64'h4A3FF3FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2119527\n");
-    end
-    x = 64'h41F10001FFFFFFFF;
-    y = 64'h4340000000000000;
-    z = 64'hE7D000000800FFFF;
-    ans = 64'hE7D000000800FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2120141\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC03F62D036C48204;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'hC06E62D036C48203;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2120755\n");
-    end
-    x = 64'hC3D00000FFFFFFFB;
-    y = 64'hC1DFFFFFFE3FFFFF;
-    z = 64'h7FEFFFFFFFEF8000;
-    ans = 64'h7FEFFFFFFFEF8000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2121369\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'h437BFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2121983\n");
-    end
-    x = 64'hC00FF00000007FFF;
-    y = 64'h3EF0200000000FFF;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE00080BF800003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2122597\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h7FE0000000000000;
-    z = 64'h3FEFEFFFFFBFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2123211\n");
-    end
-    x = 64'h8008000004000000;
-    y = 64'h41DB7E58A68A6ECF;
-    z = 64'h41C46835257E7DE1;
-    ans = 64'h41C46835257E7DE1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2123825\n");
-    end
-    x = 64'h80236BC873359E39;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h0000000000000000;
-    ans = 64'hC0236BC873359E38;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2124439\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h4C40005FFFFFFFFF;
-    z = 64'hC22FDFFFFC000000;
-    ans = 64'h4C70005FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2125053\n");
-    end
-    x = 64'h43CF80000001FFFF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hC020000000F7FFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2125667\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hFFD4C24672F919D5;
-    z = 64'h4010000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2126281\n");
-    end
-    x = 64'h7FE0000800007FFE;
-    y = 64'hC350000200000002;
-    z = 64'hBFF0018000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2126895\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h7FF0000000000001;
-    z = 64'hC340000000000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2127509\n");
-    end
-    x = 64'h7FE7FFFFFFFFFFDF;
-    y = 64'h0010002000007FFE;
-    z = 64'hBFD0000000000001;
-    ans = 64'h400600300000BFDC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2128123\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h3FCFFFFF7FFFFFBE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2128737\n");
-    end
-    x = 64'h400FF7DFFFFFFFFF;
-    y = 64'hBFF03EFFFFFFFFFE;
-    z = 64'h4FAEFFFFFFFFFFF8;
-    ans = 64'h4FAEFFFFFFFFFFF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2129351\n");
-    end
-    x = 64'hBE4001000000007F;
-    y = 64'h8000000000000000;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2129965\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h3800003FFFFFFDFE;
-    z = 64'hD1C07FFFFDFFFFFF;
-    ans = 64'hD1C07FFFFDFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2130579\n");
-    end
-    x = 64'h43407FF7FFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hC1EFFFFFFBFF7FFF;
-    ans = 64'hC1EFFFFFFBFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2131193\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC028D8C773920EEF;
-    z = 64'h4000000000000001;
-    ans = 64'hC05858C773920EEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2131807\n");
-    end
-    x = 64'hD6DF800010000000;
-    y = 64'h369E6917CE8CD5B8;
-    z = 64'hFFE00007FFFFF7FE;
-    ans = 64'hFFE00007FFFFF7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2132421\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h8010000000000000;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2133035\n");
-    end
-    x = 64'h686003FF00000000;
-    y = 64'h400FFFFFF0000400;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'h688003FEF7FE0280;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2133649\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hC7EFFFFF0000007F;
-    ans = 64'hC7EFFFFF0000007F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2134263\n");
-    end
-    x = 64'hAA0FFFFF80003FFE;
-    y = 64'hC7EFFF00007FFFFF;
-    z = 64'h3FC00000203FFFFF;
-    ans = 64'h3FC00000203FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2134877\n");
-    end
-    x = 64'hC1CF7FFFFFFFFFFC;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2135491\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h47E0BD1B124969B2;
-    z = 64'h40201FFFFFFFFFBE;
-    ans = 64'h4810BD1B124969B1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2136105\n");
-    end
-    x = 64'h0010000010000080;
-    y = 64'hBCA0000000000001;
-    z = 64'h3B8D00D9D4D54E0A;
-    ans = 64'h3B8D00D9D4D54E0A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2136719\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hB7F00000800003FF;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h3FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2137333\n");
-    end
-    x = 64'h41EFFFFFE01FFFFF;
-    y = 64'hFFEFF7FFFF800000;
-    z = 64'hFFFD03ECB3953DAA;
-    ans = 64'hFFFD03ECB3953DAA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2137947\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2138561\n");
-    end
-    x = 64'h3FE61D66F271C086;
-    y = 64'hC3F00000400000FE;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'hC3E61D674AE75DAF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2139175\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hBFD0000000000001;
-    z = 64'h800B3DE08741C4C4;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2139789\n");
-    end
-    x = 64'hB81C0000001FFFFF;
-    y = 64'hB8486203813E1F77;
-    z = 64'h12C0000000400008;
-    ans = 64'h307555C3112EBD8B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2140403\n");
-    end
-    x = 64'hBFC0200000003FFF;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2141017\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h3CAFFFF80FFFFFFF;
-    z = 64'h47220007FFFFFFFF;
-    ans = 64'h47220007FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2141631\n");
-    end
-    x = 64'h61FFFFF003FFFFFF;
-    y = 64'hBFE0000000000000;
-    z = 64'h43E0000001FFFFF6;
-    ans = 64'hE1EFFFF003FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2142245\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC3DFFFFFF0000007;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'hC40FFFFFF0000006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2142859\n");
-    end
-    x = 64'hB7F000001FFFFFFF;
-    y = 64'hC0EFFFFFFFFFC006;
-    z = 64'h7FEFFC00000FFFFF;
-    ans = 64'h7FEFFC00000FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2143473\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hC023FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2144087\n");
-    end
-    x = 64'h001FFFFFF80007FE;
-    y = 64'hCA8000040000FFFE;
-    z = 64'h8010000000000000;
-    ans = 64'h8AB00003FC0102FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2144701\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hBFF0000000000000;
-    z = 64'h41F0007FFFFFFFFC;
-    ans = 64'h41F0007FFF7FFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2145315\n");
-    end
-    x = 64'hC800080000003FFF;
-    y = 64'h40DFFFFFFFFF7FE0;
-    z = 64'hBFFFFFFFFFFFFF0F;
-    ans = 64'hC8F007FFFFFFFFCF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2145929\n");
-    end
-    x = 64'h49D0008000001FFF;
-    y = 64'hBFF0000000000001;
-    z = 64'hC340000000000000;
-    ans = 64'hC9D0008000002000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2146543\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC7F8000000000002;
-    z = 64'h3FEFFFFFFFFFFFBB;
-    ans = 64'hC828000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2147157\n");
-    end
-    x = 64'hAC48000000000007;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hC020000000040003;
-    ans = 64'hC020000000040003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2147771\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC1C7FFFF7FFFFFFF;
-    z = 64'h3FE0000000000000;
-    ans = 64'hC1F7FFFF7FF7FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2148385\n");
-    end
-    x = 64'hBC0007FFFE000000;
-    y = 64'h8005B72E93CFC238;
-    z = 64'hB1440CD30F8D6060;
-    ans = 64'hB1440CD30F8D6060;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2148999\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC000000000000001;
-    z = 64'hBFF0000000000000;
-    ans = 64'hC031000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2149613\n");
-    end
-    x = 64'h3F8FE0007FFFFFFF;
-    y = 64'h2E710000000001FF;
-    z = 64'h8000000000000001;
-    ans = 64'h2E10EF00440001FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2150227\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h43F0080000000008;
-    ans = 64'h43F0080000000008;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2150841\n");
-    end
-    x = 64'h3FF0040000080000;
-    y = 64'h4F30F7CEC7A64330;
-    z = 64'h5910E7DF0960199B;
-    ans = 64'h5910E7DF0960199B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2151455\n");
-    end
-    x = 64'h3FBF800003FFFFFE;
-    y = 64'hC010000000000000;
-    z = 64'hC010000000000001;
-    ans = 64'hC011F80000400001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2152069\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC01FFFFEDFFFFFFE;
-    z = 64'h41D0000FDFFFFFFF;
-    ans = 64'h41D0000FD000008F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2152683\n");
-    end
-    x = 64'hC090001FFF000000;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hC010000001FFFFE0;
-    ans = 64'h40BFFC3FFDFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2153297\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h414DFFFFFFFDFFFE;
-    z = 64'h3FD0000000000001;
-    ans = 64'h417E000003FDFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2153911\n");
-    end
-    x = 64'hADF0000000000101;
-    y = 64'h47FFFFBFFFFFFFEE;
-    z = 64'h768FFFEFFFFFFDFF;
-    ans = 64'h768FFFEFFFFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2154525\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC340000000000000;
-    z = 64'hBFE0000000000001;
-    ans = 64'hC36FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2155139\n");
-    end
-    x = 64'h40C000000007FFFA;
-    y = 64'h43CFFFFFFBFFFFDF;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2155753\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hCEDFFFFFD0000000;
-    ans = 64'hCEDFFFFFD0000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2156367\n");
-    end
-    x = 64'hC030001FF0000000;
-    y = 64'h24600023FFFFFFFF;
-    z = 64'hC1DFFFBFFFFF7FFF;
-    ans = 64'hC1DFFFBFFFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2156981\n");
-    end
-    x = 64'hB9E00FFFFFFFF800;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2157595\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hC34FFFFFFFF20000;
-    z = 64'h4034001FFFFFFFFE;
-    ans = 64'hC37FFFFFFFF1FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2158209\n");
-    end
-    x = 64'hC3CFFFFFBFFDFFFF;
-    y = 64'hFFE0000000000001;
-    z = 64'h4D70400000000FFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2158823\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'h001B5645AEF74677;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2159437\n");
-    end
-    x = 64'h434C0975C90677C8;
-    y = 64'h380FF0000000001F;
-    z = 64'hB7F11D571313021E;
-    ans = 64'h3B6BFB710E21F4A7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2160051\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2160665\n");
-    end
-    x = 64'h3FC1FFFFFFE00000;
-    y = 64'h3FB2000000000003;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2161279\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hFFF0000000000001;
-    z = 64'hC3D3FFFFFFE00000;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2161893\n");
-    end
-    x = 64'hC3F00000011FFFFF;
-    y = 64'hCC3FFFFFFFFFE00E;
-    z = 64'hA29FFFFFFFFFF7FE;
-    ans = 64'h50400000011FF006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2162507\n");
-    end
-    x = 64'hC3D4800000000000;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2163121\n");
-    end
-    x = 64'h401FFFFFFFFFFFFF;
-    y = 64'hFFD0D5461AB97F96;
-    z = 64'h41CB0920A36D44D9;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2163735\n");
-    end
-    x = 64'h41FFF7FFFFFFFFDE;
-    y = 64'h0000000000000000;
-    z = 64'hE76A841E3E18C6FF;
-    ans = 64'hE76A841E3E18C6FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2164349\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h41E020000007FFFF;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h421020000007FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2164963\n");
-    end
-    x = 64'hC3FE4FBC9B42F5B4;
-    y = 64'h40200080000007FE;
-    z = 64'hB80FF7FFFFDFFFFF;
-    ans = 64'hC42E50AF1927DEF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2165577\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBCAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2166191\n");
-    end
-    x = 64'h480BCB365F69F57F;
-    y = 64'h40738DF7B187116B;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2166805\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h0010000000000000;
-    z = 64'hC000070A5DABB9D0;
-    ans = 64'hC000070A5DABB9D0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2167419\n");
-    end
-    x = 64'h2CC928717C7B85D4;
-    y = 64'hBE37BC475F020AD5;
-    z = 64'h41EFFFFFFFFEFDFF;
-    ans = 64'h41EFFFFFFFFEFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2168033\n");
-    end
-    x = 64'hBFC144B4875A348D;
-    y = 64'h0010000000000001;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2168647\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h2840000080000000;
-    z = 64'h4030922251CA0B50;
-    ans = 64'h4030922251CA0B50;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2169261\n");
-    end
-    x = 64'h402FFFFBFF7FFFFF;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hF8CFFE007FFFFFFF;
-    ans = 64'hF8CFFE007FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2169875\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hC0FBFFFFFFFFFFF0;
-    z = 64'h0010000000000000;
-    ans = 64'hC12BFFFFFFFFFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2170489\n");
-    end
-    x = 64'hC500000800800000;
-    y = 64'h41FFFFFFFFBFFFFC;
-    z = 64'hB80BD40508FA289F;
-    ans = 64'hC7100008005FFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2171103\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h3CA0000000000001;
-    z = 64'hBCA0000000000000;
-    ans = 64'h3CCC000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2171717\n");
-    end
-    x = 64'h3CA0000080000FFE;
-    y = 64'h380DFFFF00000000;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2172331\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h000FFFFDFFFFEFFF;
-    ans = 64'h3CDFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2172945\n");
-    end
-    x = 64'hC3F000000003FF00;
-    y = 64'h405BFFFFFE000000;
-    z = 64'h3FAFFFFFFFFE1FFF;
-    ans = 64'hC45BFFFFFE06FE40;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2173559\n");
-    end
-    x = 64'hBFD911DFB7F9CEDD;
-    y = 64'h3FD0000000000000;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE3223BF6FF39DD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2174173\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h32EFFFFFF7F7FFFF;
-    z = 64'hC800000000FFFFC0;
-    ans = 64'hC800000000FFFFC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2174787\n");
-    end
-    x = 64'hBF0FFFFF10000000;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hC950000BFFFFFFFF;
-    ans = 64'hC950000BFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2175401\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hC0E00100000001FE;
-    z = 64'h0000000000000001;
-    ans = 64'hC1100100000001FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2176015\n");
-    end
-    x = 64'hC1FFFDFFFFF80000;
-    y = 64'h40AFFC000000003E;
-    z = 64'h7FD69A1CC85982DA;
-    ans = 64'h7FD69A1CC85982DA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2176629\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h3FE0000000000000;
-    z = 64'h8010000000000001;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2177243\n");
-    end
-    x = 64'hBC30400000FFFFFE;
-    y = 64'hC02FFFBFF7FFFFFF;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2177857\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h41FFFFFB7FFFFFFF;
-    ans = 64'h41FFFFFB807FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2178471\n");
-    end
-    x = 64'hBFE3DC34614FE233;
-    y = 64'h407F3395996D3BDD;
-    z = 64'h000FFFFFFFFFFFF5;
-    ans = 64'hC0735D568A4D0539;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2179085\n");
-    end
-    x = 64'h43EA1727CA3DE0E5;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'h43EA1727CA3DE0E3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2179699\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hBE2E7FFFFFFFFFFF;
-    z = 64'h3FE0101FFFFFFFFF;
-    ans = 64'h3FE0101FF0BFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2180313\n");
-    end
-    x = 64'h41F352E0B6A41A6F;
-    y = 64'h3FF0000000000001;
-    z = 64'hC3F1FFFFFFFFF7FE;
-    ans = 64'hC3F1FFFFFFECA51D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2180927\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hBF139BBEA43347D1;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2181541\n");
-    end
-    x = 64'hC03D8D9F3E07CDB5;
-    y = 64'h434FFFFFFE07FFFF;
-    z = 64'hBF15743D92475450;
-    ans = 64'hC39D8D9F3C365728;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2182155\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h402FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2182769\n");
-    end
-    x = 64'h380733B41F678237;
-    y = 64'h3FF00000207FFFFF;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2183383\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h4000000000000001;
-    z = 64'hC7F001FFFFFFFF80;
-    ans = 64'hC7F001FFFFFFFF80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2183997\n");
-    end
-    x = 64'h38130C2AD3A6C0EA;
-    y = 64'h40100001000001FF;
-    z = 64'hB80FFDFFFFFBFFFF;
-    ans = 64'h382E18D808D3E10A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2184611\n");
-    end
-    x = 64'hC6DFFFFFFFFFFF03;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hC6FFFFFFFFFFFF02;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2185225\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hC1F6594B8FFA4BB7;
-    z = 64'h43C2000000000007;
-    ans = 64'h43C1FFFFFA69AD23;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2185839\n");
-    end
-    x = 64'h3FC00000001E0000;
-    y = 64'h4010000000000000;
-    z = 64'h7B6FFFBFFFFDFFFF;
-    ans = 64'h7B6FFFBFFFFDFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2186453\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h63DFFEFFFFFFF7FF;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2187067\n");
-    end
-    x = 64'h43AFFFFFFFFFFC02;
-    y = 64'h3E600000002000FF;
-    z = 64'hC1EFFFFFFFE3FFFF;
-    ans = 64'h421C000000437E00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2187681\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2188295\n");
-    end
-    x = 64'hBEEFFFFC000000FF;
-    y = 64'hC34F7FFFFFFF7FFF;
-    z = 64'h4000000000000000;
-    ans = 64'h424F7FFC100080FA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2188909\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h4340000000000000;
-    z = 64'hC25D8DAAFC9DDB29;
-    ans = 64'h436FFFF1392A81AF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2189523\n");
-    end
-    x = 64'hC0E000002FFFFFFF;
-    y = 64'hC00FBFFFBFFFFFFE;
-    z = 64'h0AEFFFFF7EFFFFFF;
-    ans = 64'h40FFC0001F3FFF3C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2190137\n");
-    end
-    x = 64'h4A104315AC3EB886;
-    y = 64'h4340000000000001;
-    z = 64'hBCA0000000000000;
-    ans = 64'h4D604315AC3EB887;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2190751\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hC7407FFFFFFFFFFB;
-    z = 64'hC011FFFEFFFFFFFE;
-    ans = 64'hC7707FFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2191365\n");
-    end
-    x = 64'hC7FFC00080000000;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hBFB0000004007FFF;
-    ans = 64'hCB5FC0007FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2191979\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h403FBFFFFFFFFE00;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2192593\n");
-    end
-    x = 64'h4032000000003FFF;
-    y = 64'h3FBFFFFFBFFFFFDF;
-    z = 64'hBD50007FFF000000;
-    ans = 64'h4001FFFFDC003DEC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2193207\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h7FE0000000000001;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2193821\n");
-    end
-    x = 64'h3FEFFDFFFFFF8000;
-    y = 64'h0005C9224A1E956A;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2194435\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h3F8001000000FFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2195049\n");
-    end
-    x = 64'hC03FFFFFFEFFFFF0;
-    y = 64'hB9CFC0000000007F;
-    z = 64'hBFEB1648C4E67458;
-    ans = 64'hBFEB1648C4E67458;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2195663\n");
-    end
-    x = 64'hBEBFFFFFFFF7F7FF;
-    y = 64'h7FF0000000000000;
-    z = 64'h8010000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2196277\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h820000FFFFFFFFFB;
-    z = 64'h37FFFFFFFFF7FEFE;
-    ans = 64'h37FFFFFFFFF7FEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2196891\n");
-    end
-    x = 64'h7E20BFFFFFFFFFFF;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h3D500000000FBFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2197505\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h28AFBFFFFFFFFFFE;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2198119\n");
-    end
-    x = 64'h3064B981E97CBA0F;
-    y = 64'h5D5FFFFFFFFF01FF;
-    z = 64'h0020004000000001;
-    ans = 64'h4DD4B981E97C158E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2198733\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h8000000000000000;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2199347\n");
-    end
-    x = 64'h801007FFFBFFFFFF;
-    y = 64'hC030000400000400;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2199961\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h8000000000000001;
-    z = 64'hBBB9E662CC81018C;
-    ans = 64'hBBB9E662CC81018C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2200575\n");
-    end
-    x = 64'hC54002000003FFFF;
-    y = 64'h3E02EC0486B0BE36;
-    z = 64'h3FD0403FFFFFFFFE;
-    ans = 64'hC352EE6207464F4E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2201189\n");
-    end
-    x = 64'h41FFFFFF80000200;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h821FFFFF801001FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2201803\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hC1E00043FFFFFFFE;
-    z = 64'hB7EFE0000000007E;
-    ans = 64'hC2100043FFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2202417\n");
-    end
-    x = 64'h401007FFEFFFFFFF;
-    y = 64'h8010000000000001;
-    z = 64'hC7EF672408576C70;
-    ans = 64'hC7EF672408576C70;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2203031\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h40400007FFEFFFFE;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'h406F000FFFDFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2203645\n");
-    end
-    x = 64'hC3848D211BED45F4;
-    y = 64'h41C40000000FFFFF;
-    z = 64'hC770000000407FFF;
-    ans = 64'hC77000000046EC19;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2204259\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2204873\n");
-    end
-    x = 64'h0E2000207FFFFFFE;
-    y = 64'hBCCFFFF6FFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2205487\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hBCA0000000000000;
-    z = 64'hC01EFFFFFFFFFFFE;
-    ans = 64'hC01EFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2206101\n");
-    end
-    x = 64'h37EE0000003FFFFF;
-    y = 64'hFFEFFFF600000000;
-    z = 64'hBFCFEFFEFFFFFFFF;
-    ans = 64'hF7EDFFF6A03FFFEB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2206715\n");
-    end
-    x = 64'hC050020000000FFF;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2207329\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hC3400003FFFFFFFD;
-    z = 64'h37F0001000000002;
-    ans = 64'hC3700003FFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2207943\n");
-    end
-    x = 64'hBFC0000001BFFFFF;
-    y = 64'hBFD0000000000000;
-    z = 64'h37F104AA7323DE0F;
-    ans = 64'h3FA0000001BFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2208557\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h8000001FFF800000;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2209171\n");
-    end
-    x = 64'h3EEFEAB58D93A8FE;
-    y = 64'hB7FFFFFFFFFFE03E;
-    z = 64'h3FF0000000001F7E;
-    ans = 64'h3FF0000000001F7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2209785\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2210399\n");
-    end
-    x = 64'h400BE6A8C346FFA8;
-    y = 64'h381F7FFFFFFFFFFE;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2211013\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'hBD60000080008000;
-    ans = 64'hC0100000000001FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2211627\n");
-    end
-    x = 64'h3FFFFFFFF0000000;
-    y = 64'h3FC4000000000FFE;
-    z = 64'hBFFFFFFFFFFFFFF9;
-    ans = 64'hBFFB0000027FFBFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2212241\n");
-    end
-    x = 64'h41D0000000000807;
-    y = 64'hBFE0000000000001;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2212855\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h3FDC01FFFFFFFFFE;
-    z = 64'hC3F0000401FFFFFE;
-    ans = 64'hC3F0000401FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2213469\n");
-    end
-    x = 64'hC80F13ECC2137E16;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hFFEFFFF8000003FE;
-    ans = 64'hFFEFFFF8000003FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2214083\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hC1EFFFFF80040000;
-    z = 64'hC000000000000000;
-    ans = 64'hC21FFFFF800BFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2214697\n");
-    end
-    x = 64'hC000FFFF00000000;
-    y = 64'hBFC00000003FFF7F;
-    z = 64'h3FAFFFFFFFDFFBFF;
-    ans = 64'h3FD4FFFF003FFEF3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2215311\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hBFF0000000000001;
-    z = 64'h4010000000000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2215925\n");
-    end
-    x = 64'h48A03FFFFFFFBFFF;
-    y = 64'h4061FF7FFFFFFFFF;
-    z = 64'h3CA0000000000001;
-    ans = 64'h4912477DFFFFB800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2216539\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h40BFFFBFFFFFF7FF;
-    ans = 64'h40BFEFBFFFFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2217153\n");
-    end
-    x = 64'h379ED1F6EA8D1110;
-    y = 64'hB810000000800100;
-    z = 64'h80203FFFF7FFFFFF;
-    ans = 64'hAFBED1F6EB83A2B4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2217767\n");
-    end
-    x = 64'hC1C05A35ECCACC30;
-    y = 64'hC000000000000000;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2218381\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hBDD000000800000F;
-    z = 64'h3FCFFFC0001FFFFF;
-    ans = 64'h3FCFFFBFFF1FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2218995\n");
-    end
-    x = 64'h43F000003FFFEFFF;
-    y = 64'hC000000000000001;
-    z = 64'h001FFFFFE000000E;
-    ans = 64'hC40000003FFFF000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2219609\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hC1E0008000800000;
-    z = 64'hBFF0000000000001;
-    ans = 64'hC21000800083FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2220223\n");
-    end
-    x = 64'h3FA00000000007C0;
-    y = 64'h41CFF7FFFFFF7FFE;
-    z = 64'h43CFFFFFFF8003FE;
-    ans = 64'h43CFFFFFFF8103BE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2220837\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hC010000000000000;
-    z = 64'h4000000000000001;
-    ans = 64'hC03DFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2221451\n");
-    end
-    x = 64'hBFCFFFE0FFFFFFFF;
-    y = 64'h3FBBCBE88BA8381B;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'hBF9BCBCD9E1EF0CF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2222065\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hC010000000000001;
-    z = 64'h5030000FFFFFFBFF;
-    ans = 64'h5030000FFFFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2222679\n");
-    end
-    x = 64'h6105A870582F21FC;
-    y = 64'hC170001FBFFFFFFF;
-    z = 64'h8010000180000000;
-    ans = 64'hE285A89B526E10F8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2223293\n");
-    end
-    x = 64'h41DD898416FC5476;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFE2767BE8F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2223907\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h404FFFFFFFFFFCFF;
-    z = 64'h3FAFFEFFFFFFFFFC;
-    ans = 64'h4080007FFBFFFE7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2224521\n");
-    end
-    x = 64'hC7FFFF80000001FE;
-    y = 64'hC340000000000000;
-    z = 64'h411FFFFFFFF7FFDE;
-    ans = 64'h4B4FFF80000001FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2225135\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'h8000C97BEE00D34B;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2225749\n");
-    end
-    x = 64'h62FFFFFFF1000000;
-    y = 64'h3873FFFFFFFFFF80;
-    z = 64'h24AFBFFFFFFFDFFF;
-    ans = 64'h5B83FFFFF69FFF80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2226363\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'hC37FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2226977\n");
-    end
-    x = 64'h304003FFBFFFFFFF;
-    y = 64'h3FE2FABF1F6AD441;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h3032FF7D8347B277;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2227591\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hFFE0000000000000;
-    z = 64'hA3D00000000FFFFA;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2228205\n");
-    end
-    x = 64'hFFFFFFBFF0000000;
-    y = 64'h4BFFFFFFBFFFFFC0;
-    z = 64'h40F007F7FFFFFFFF;
-    ans = 64'hFFFFFFBFF0000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2228819\n");
-    end
-    x = 64'hBFC000004000000E;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h7FC000004000000D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2229433\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hAE3FFFFFFFEFFFFF;
-    z = 64'h400FFFFFFFE0FFFF;
-    ans = 64'h400FFFFFFFE0FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2230047\n");
-    end
-    x = 64'h47F00FFFFFFBFFFF;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h3FAFFFFFBFFFFFFC;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2230661\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hC02FFF9FFFFFFFFE;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hC0600FCFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2231275\n");
-    end
-    x = 64'hC348A49D10BEDDE4;
-    y = 64'h400276F4846B6206;
-    z = 64'h68D007FFFFFFFFDF;
-    ans = 64'h68D007FFFFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2231889\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2232503\n");
-    end
-    x = 64'hB8011C56478F348C;
-    y = 64'h403FFFEFFFFE0000;
-    z = 64'h0000000000000000;
-    ans = 64'hB8511C4DB962FEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2233117\n");
-    end
-    x = 64'h401FFFFFFFFFFFFE;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hBFEFFFFFF0000000;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2233731\n");
-    end
-    x = 64'h3FC11A069589BC39;
-    y = 64'h3FCF800000004000;
-    z = 64'h40334BF615A75C67;
-    ans = 64'h40335460E4E4F643;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2234345\n");
-    end
-    x = 64'h41900000200001FF;
-    y = 64'h0000000000000001;
-    z = 64'h4010000000000000;
-    ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2234959\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBFF47A6831A030F5;
-    z = 64'hC34000000007FFFB;
-    ans = 64'hC3523D3418D41878;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2235573\n");
-    end
-    x = 64'h2BB4FBFBC886F231;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h3CA5AB28C6CBDEAA;
-    ans = 64'h3CA5AB28C6CBDEAA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2236187\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBCF758AF3B14EB32;
-    z = 64'hBFD0000000000000;
-    ans = 64'hC04778AF3B14EB32;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2236801\n");
-    end
-    x = 64'hC1F001FFFFFEFFFF;
-    y = 64'h480ADA0454848A3E;
-    z = 64'h43EFFFFC0000001F;
-    ans = 64'hCA0ADD5F950D6D2D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2237415\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h0010000000000001;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2238029\n");
-    end
-    x = 64'hBFF5EF24C8F3E7E4;
-    y = 64'hC6B07FFFFE000000;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2238643\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h3FDFFFFFF7FFFF00;
-    ans = 64'h3FDFFFFFF7FFFF00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2239257\n");
-    end
-    x = 64'hC02A9F0B59060CA0;
-    y = 64'h210FFFFFFFBBFFFE;
-    z = 64'hB810000000FFFF7F;
-    ans = 64'hB810000000FFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2239871\n");
-    end
-    x = 64'hB7E000000000F000;
-    y = 64'h3CA0000000000000;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2240485\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h3D80001FFFEFFFFF;
-    z = 64'hC96FFFFFFFFBF800;
-    ans = 64'hC96FFFFFFFFBF800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2241099\n");
-    end
-    x = 64'hBFC00000000101FF;
-    y = 64'h3CA0000000000001;
-    z = 64'hBF10000008000003;
-    ans = 64'hBF10000008000403;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2241713\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBFC531280B222900;
-    z = 64'hBCA0000000000001;
-    ans = 64'hC31531280B222900;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2242327\n");
-    end
-    x = 64'h3CA490ECEFD38623;
-    y = 64'h414FFFFBFFF7FFFF;
-    z = 64'hD120003FFFDFFFFE;
-    ans = 64'hD120003FFFDFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2242941\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h3FD0000000000000;
-    z = 64'h3FD0000000000001;
-    ans = 64'h4320000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2243555\n");
-    end
-    x = 64'hC1D0003FFFF80000;
-    y = 64'hC7F0000000FEFFFE;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2244169\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h3FD0000000000001;
-    z = 64'hC5F79471ABFF5855;
-    ans = 64'hC5F79471ABFF57D5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2244783\n");
-    end
-    x = 64'hC3C64F7F32A01115;
-    y = 64'h41D0001FFFBFFFFF;
-    z = 64'h43E00010000007FF;
-    ans = 64'hC5A64FABD0453757;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2245397\n");
-    end
-    x = 64'h3FE8325AA8E5EF61;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h4003064B551CBDEB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2246011\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h4B220E85F7748991;
-    z = 64'h5D7BFF8C86E1490E;
-    ans = 64'h5D7BFF8C86E1490E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2246625\n");
-    end
-    x = 64'h00009E4D8E813566;
-    y = 64'h3FE0000000000000;
-    z = 64'hC8000000001C0000;
-    ans = 64'hC8000000001C0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2247239\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h3FF00007FFFFFF00;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h43400007FFFFFF00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2247853\n");
-    end
-    x = 64'h3D19EFC2065BEF14;
-    y = 64'hBFB0B74B5345ADF2;
-    z = 64'hC3D441E6C3A83622;
-    ans = 64'hC3D441E6C3A83622;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2248467\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h433FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2249081\n");
-    end
-    x = 64'h37FFFFE000004000;
-    y = 64'h0010003EFFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2249695\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h3FF0000000000000;
-    z = 64'h3FDC11549B9F5AA7;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2250309\n");
-    end
-    x = 64'h7FEA9F96DC0C28C0;
-    y = 64'hC010000000001BFF;
-    z = 64'hC7EFFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2250923\n");
-    end
-    x = 64'h41FB29AFFFECD92D;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h420B29AFFFF4D92C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2251537\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hEBDFFDFF00000000;
-    z = 64'h413832D2DC13B5B9;
-    ans = 64'hEF2FFDFF00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2252151\n");
-    end
-    x = 64'hC3D0000080001FFE;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h001EFFFFDFFFFFFF;
-    ans = 64'hC3E0000080001FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2252765\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h32540000000FFFFF;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h35A40000000FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2253379\n");
-    end
-    x = 64'hB7EFFFFFFFF7FEFE;
-    y = 64'hBCCFE0FFFFFFFFFF;
-    z = 64'h403387575FCA1664;
-    ans = 64'h403387575FCA1664;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2253993\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h435FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2254607\n");
-    end
-    x = 64'hC010000010007FFE;
-    y = 64'hD3C0000000800002;
-    z = 64'hC340000000000000;
-    ans = 64'h53E0000010808001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2255221\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h40440FFFFFFFFFFE;
-    ans = 64'h4360000000000004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2255835\n");
-    end
-    x = 64'hC00C00F1226B2050;
-    y = 64'h3FFFFFDFFFFFFBFE;
-    z = 64'h37E0000000FDFFFF;
-    ans = 64'hC01C00D52179FA63;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2256449\n");
-    end
-    x = 64'hCD7FFFFFFFFF7FFF;
-    y = 64'h4010000000000001;
-    z = 64'h3FE0000000000000;
-    ans = 64'hCD9FFFFFFFFF8001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2257063\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h55E00001FEFFFFFE;
-    z = 64'h3CAFBFFFFFDFFFFF;
-    ans = 64'h59300001FEFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2257677\n");
-    end
-    x = 64'hC7FFFFFFFC01FFFE;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hC3EFF0007FFFFFFF;
-    ans = 64'hC82FFFFFFC01FFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2258291\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h7FFFFFBFFFFEFFFF;
-    z = 64'h8000000000000000;
-    ans = 64'h7FFFFFBFFFFEFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2258905\n");
-    end
-    x = 64'hBF8FC0000FFFFFFE;
-    y = 64'hC02FFFFBFFF00000;
-    z = 64'hBFEFFFFFBFF00000;
-    ans = 64'hBFE81000B9F3F881;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2259519\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h4340000000000001;
-    z = 64'h0010000000000000;
-    ans = 64'h4690000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2260133\n");
-    end
-    x = 64'hBFF0003FFF000000;
-    y = 64'hB13F48933B2117B6;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2260747\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h425975F42BB1D3BE;
-    ans = 64'h469FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2261361\n");
-    end
-    x = 64'h43E000000000017E;
-    y = 64'hBC6FFFFF800003FF;
-    z = 64'hB81000004FFFFFFE;
-    ans = 64'hC05FFFFF800006FB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2261975\n");
-    end
-    x = 64'hC16FFBFFFFFFFFFF;
-    y = 64'h7FE0000000000000;
-    z = 64'h3FD0000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2262589\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBCCFFFFFFE0007FF;
-    z = 64'h41DCB061BF22B973;
-    ans = 64'h41DCB061BD22B973;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2263203\n");
-    end
-    x = 64'hB4400000000FFFFF;
-    y = 64'h7FE0000000000001;
-    z = 64'hC3476B9F80980CE3;
-    ans = 64'hF430000000100000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2263817\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBFEF5455E66D6359;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2264431\n");
-    end
-    x = 64'hC3D71608E45A0412;
-    y = 64'hC0180000001FFFFE;
-    z = 64'h6B0000FFFFFFFDFF;
-    ans = 64'h6B0000FFFFFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2265045\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h7FF0000000000000;
-    z = 64'h0000000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2265659\n");
-    end
-    x = 64'hB86F21204321D590;
-    y = 64'hAF3FFFFFFBFFE000;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2266273\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h7FF0000000000001;
-    z = 64'hBF8FFFBFFFFFFEFE;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2266887\n");
-    end
-    x = 64'h6D50100000007FFF;
-    y = 64'h41FC0000001FFFFF;
-    z = 64'hC1FF398F11A754F1;
-    ans = 64'h6F5C1C000020FFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2267501\n");
-    end
-    x = 64'hFFEA6D705F94B444;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2268115\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h41D0003FFFFF0000;
-    z = 64'h3AA3FFFFFFEFFFFF;
-    ans = 64'h4520003FFFFF0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2268729\n");
-    end
-    x = 64'h43FCE6E55903E977;
-    y = 64'h8000000000000000;
-    z = 64'hBC4FFDFFFFFFF7FF;
-    ans = 64'hBC4FFDFFFFFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2269343\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h37EB5BDAF53EB4EB;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2269957\n");
-    end
-    x = 64'h3F7FFFFFFFFEF000;
-    y = 64'h3FDFFFFFF8000100;
-    z = 64'hBED000FFFFFFFBFF;
-    ans = 64'h3F6FF7FF77FEF102;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2270571\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2271185\n");
-    end
-    x = 64'h77CFFFE00000000F;
-    y = 64'h3F1FFFF80FFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'h76FFFFD81007F00E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2271799\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h8010000000000000;
-    z = 64'hC3707FFFFFFFFDFF;
-    ans = 64'hC3707FFFFFFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2272413\n");
-    end
-    x = 64'h002FFFDFFFFFFFDE;
-    y = 64'h3E8FF00000000100;
-    z = 64'h40811626F5BEB56D;
-    ans = 64'h40811626F5BEB56D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2273027\n");
-    end
-    x = 64'hC7EC000000000010;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h081C00000000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2273641\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h4010000000000201;
-    z = 64'h801000000200FFFE;
-    ans = 64'h4360000000000201;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2274255\n");
-    end
-    x = 64'h41B0000000000DFF;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h40202FFFAD16AF0E;
-    ans = 64'h40202FFFAD16AF0E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2274869\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hC36D72FC4F782B37;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'hC6BD72FC4F782B37;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2275483\n");
-    end
-    x = 64'hDB8FFFFFFE00007E;
-    y = 64'h9FC000003FDFFFFF;
-    z = 64'h4034F071C6234836;
-    ans = 64'h4034F071C6234836;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2276097\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBCA0000000000001;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2276711\n");
-    end
-    x = 64'h47F00023FFFFFFFF;
-    y = 64'h359F000020000000;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFEFFFFFFFFF07FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2277325\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h64BFFFFFFDFF7FFE;
-    ans = 64'h64BFFFFFFDFF7FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2277939\n");
-    end
-    x = 64'h43DFFFFFFF007FFE;
-    y = 64'h400FFBFFFFFFBFFF;
-    z = 64'h3FFF8000FFFFFFFF;
-    ans = 64'h43FFFBFFFF005FED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2278553\n");
-    end
-    x = 64'hBF30000000200400;
-    y = 64'hBFD0000000000001;
-    z = 64'h0010000000000000;
-    ans = 64'h3F10000000200401;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2279167\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h3FFB2B4407EDF5B5;
-    z = 64'hBFD000000001FEFE;
-    ans = 64'h434B2B4407EDF5B5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2279781\n");
-    end
-    x = 64'hC641F08986F4CAEF;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h4037FDFFFFFFFFFE;
-    ans = 64'h4631F08986F4CAEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2280395\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBFF6A9ACDE055875;
-    z = 64'h4340000000000000;
-    ans = 64'hC32AA6B3781561D4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2281009\n");
-    end
-    x = 64'hC077209428630E48;
-    y = 64'h3F9BFFFFFFFFFEFF;
-    z = 64'h7DEFFFFFFEFFF800;
-    ans = 64'h7DEFFFFFFEFFF800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2281623\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBFE0000000000000;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2282237\n");
-    end
-    x = 64'hB7EC000000007FFE;
-    y = 64'h802DFFF7FFFFFFFF;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2282851\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hBFD1311DCA7752FE;
-    ans = 64'hC33FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2283465\n");
-    end
-    x = 64'h7FFC036815DA618A;
-    y = 64'h3FA2B0315180BE7A;
-    z = 64'h001A394446183D85;
-    ans = 64'h7FFC036815DA618A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2284079\n");
-    end
-    x = 64'h47FFFFFFFFFFFFFF;
-    y = 64'hBFF0000000000000;
-    z = 64'h0000000000000001;
-    ans = 64'hC7FFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2284693\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hB25FFFDFFFBFFFFF;
-    z = 64'hA20F7F3E8492CDF4;
-    ans = 64'hB5AFFFDFFFBFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2285307\n");
-    end
-    x = 64'hC00D57DC0A031EEA;
-    y = 64'hBFF0000000000001;
-    z = 64'h4440000040000200;
-    ans = 64'h4440000040000200;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2285921\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hC7F0000BFFFFFFFF;
-    z = 64'h4010000000000001;
-    ans = 64'hCB40000BFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2286535\n");
-    end
-    x = 64'hCD6FFBBFFFFFFFFF;
-    y = 64'h434FFFFFFF7FFBFF;
-    z = 64'h0020949B37C68B32;
-    ans = 64'hD0CFFBBFFF800CFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2287149\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hC340000000000001;
-    ans = 64'hC358000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2287763\n");
-    end
-    x = 64'hBFF07FFFFFFEFFFF;
-    y = 64'hC34FFFFFFFFFEF7F;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'h43507FFFFFFEF77C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2288377\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hC000000000000001;
-    z = 64'hC92C1CF2ED58314F;
-    ans = 64'hC92C1CF2ED58314F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2288991\n");
-    end
-    x = 64'h41CCAE6C2A82DBEE;
-    y = 64'h3CA00001F7FFFFFF;
-    z = 64'h40A8D91B4EE4EC1F;
-    ans = 64'h40A8D91B4EE881ED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2289605\n");
-    end
-    x = 64'h434FF000000003FE;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2290219\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hC002CB498F049251;
-    z = 64'h70DFFFFF00003FFE;
-    ans = 64'h70DFFFFF00003FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2290833\n");
-    end
-    x = 64'hC03FFFFFFFC00001;
-    y = 64'hC010000000000000;
-    z = 64'h7FFFC00000000100;
-    ans = 64'h7FFFC00000000100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2291447\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hC3EEA4A69C2CA85E;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'hC73EA4A69C2CA85E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2292061\n");
-    end
-    x = 64'hC3FFFFFFFB7FFFFF;
-    y = 64'hCEFDFFFFBFFFFFFF;
-    z = 64'h3CCFFFFFFFC0007F;
-    ans = 64'h530DFFFFBBC80007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2292675\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC370000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2293289\n");
-    end
-    x = 64'hC090010000007FFE;
-    y = 64'h8007AEAE57E64007;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBCAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2293903\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hC340000000000000;
-    z = 64'hD690000003FFFFF7;
-    ans = 64'hD690000003FFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2294517\n");
-    end
-    x = 64'hB80FFFEFFFFFFFEF;
-    y = 64'hC3DFFFFFF7FFFFFE;
-    z = 64'h47E887DAC10630D3;
-    ans = 64'h47E887DAC10630D3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2295131\n");
-    end
-    x = 64'hDFAFEFFBFFFFFFFE;
-    y = 64'hC340000000000001;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2295745\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'h388FFFFF8000001F;
-    z = 64'hC008001FFFFFFFFE;
-    ans = 64'hC008001FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2296359\n");
-    end
-    x = 64'hC01FFFFFFFBFFDFE;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h3F6FFFFFFFF0FFFF;
-    ans = 64'h437FFFFFFFBFFDFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2296973\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBFDF5FFFFFFFFFFE;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'hC32F5FFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2297587\n");
-    end
-    x = 64'hC03EFFFFFFFEFFFF;
-    y = 64'h401FFFFBC0000000;
-    z = 64'hC011FFFFFDFFFFFF;
-    ans = 64'hC06F8FFBE1EEFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2298201\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hFFE0000000000001;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2298815\n");
-    end
-    x = 64'hA71F000000000002;
-    y = 64'h43E0000007F00000;
-    z = 64'hBCA0000000000000;
-    ans = 64'hBCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2299429\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hC1CFF7FFFFFFFDFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2300043\n");
-    end
-    x = 64'h43C0001000000200;
-    y = 64'h7FF00010007FFFFE;
-    z = 64'hC02FFE000001FFFF;
-    ans = 64'h7FF80010007FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2300657\n");
-    end
-    x = 64'h41E0000800000040;
-    y = 64'hFFF0000000000000;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2301271\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hBFDF7FFFFF7FFFFF;
-    z = 64'h43DFFFFFFE000003;
-    ans = 64'h43DFFC0FFE001003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2301885\n");
-    end
-    x = 64'hBFB42B92E0CE8966;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h401FFFC000000400;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2302499\n");
-    end
-    x = 64'h4340000000000000;
-    y = 64'hC3E000007FFFFFFE;
-    z = 64'h3FF0000000000000;
-    ans = 64'hC73000007FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2303113\n");
-    end
-    x = 64'h43DBFFFFFFFF0000;
-    y = 64'h37FB3FA406ED06DD;
-    z = 64'hBF4000007FFFC000;
-    ans = 64'hBF4000007FFFC000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2303727\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h0000000000000000;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2304341\n");
-    end
-    x = 64'hBF3000000001FFEE;
-    y = 64'h7FDFFFFFE001FFFF;
-    z = 64'h8010000000000001;
-    ans = 64'hFF1FFFFFE005FFDB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2304955\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hC00000000001EFFF;
-    ans = 64'hC00000000001EFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2305569\n");
-    end
-    x = 64'h41E00000F0000000;
-    y = 64'hC1FFFFFF801FFFFF;
-    z = 64'h3A0C007FFFFFFFFF;
-    ans = 64'hC3F00000B00FFC40;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2306183\n");
-    end
-    x = 64'h434AA2D8FC9A46F1;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2306797\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h5290000FFFFFFF80;
-    z = 64'hC0253D605ADC6994;
-    ans = 64'h55E0000FFFFFFF81;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2307411\n");
-    end
-    x = 64'h40300000047FFFFF;
-    y = 64'h0010000000000001;
-    z = 64'h40028347123FC721;
-    ans = 64'h40028347123FC721;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2308025\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h402FFDFFFFFFFFFA;
-    z = 64'h3FE0000000000001;
-    ans = 64'h437FFDFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2308639\n");
-    end
-    x = 64'hBFFFFFFFFFF7F7FE;
-    y = 64'h4003FB7F21F644D6;
-    z = 64'hB81FFFFFF7FFFF80;
-    ans = 64'hC013FB7F21F140F6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2309253\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2309867\n");
-    end
-    x = 64'hC3CFFFFF80010000;
-    y = 64'h282FFFFFFFFFC000;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'hAC0FFFFF8000C000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2310481\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h3CA0000000000001;
-    z = 64'h41D15D35F884E088;
-    ans = 64'h41D15D35F8C4E088;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2311095\n");
-    end
-    x = 64'h401FDFFFFFFFFFFC;
-    y = 64'h43F8C520AF7D5809;
-    z = 64'h001FFFFFFFFFE7FF;
-    ans = 64'h4428AC5B8ECDDAAE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2311709\n");
-    end
-    x = 64'h37E0000001FBFFFF;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2312323\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h404A43217BCC7B0C;
-    z = 64'h3E8000080003FFFF;
-    ans = 64'h439A43217BCC7B0E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2312937\n");
-    end
-    x = 64'h60F00000200001FF;
-    y = 64'h3FD0000000000000;
-    z = 64'hBFDEFFFFFFFFEFFF;
-    ans = 64'h60D00000200001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2313551\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h7FFFFFFFFFFFFC06;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFC06;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2314165\n");
-    end
-    x = 64'hC0225253367BEB29;
-    y = 64'hBFFFFC00000FFFFE;
-    z = 64'h3F0FFDFFFFC00000;
-    ans = 64'h4032500CEBDE44CC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2314779\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'h432FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2315393\n");
-    end
-    x = 64'h434000000003FFFF;
-    y = 64'h43479024D7FF09EF;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2316007\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h3FE0000000000000;
-    z = 64'h33DFFE000FFFFFFF;
-    ans = 64'h4330000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2316621\n");
-    end
-    x = 64'h37E0000000000000;
-    y = 64'h79D7A559DDB1F430;
-    z = 64'h3E70001000001FFF;
-    ans = 64'h71C7A559DDB1F430;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2317235\n");
-    end
-    x = 64'hC7FF80000FFFFFFF;
-    y = 64'h3FE0000000000001;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC7EF800010000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2317849\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hBCAB7CDC15514299;
-    z = 64'hC3F000001FFFF7FF;
-    ans = 64'hC3F000001FFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2318463\n");
-    end
-    x = 64'hB05001FFFFF00000;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hFFFFFFEFFFFFBFFE;
-    ans = 64'hFFFFFFEFFFFFBFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2319077\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h410D90149AC990FB;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h445D90149AC990FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2319691\n");
-    end
-    x = 64'h41CFE003FFFFFFFF;
-    y = 64'h402DFFFFFFFFFFFE;
-    z = 64'h52076C977151EFF0;
-    ans = 64'h52076C977151EFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2320305\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h3FF0000000000001;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'h4340000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2320919\n");
-    end
-    x = 64'hC80FEFFFFFFFDFFE;
-    y = 64'hC8001FDFFFFFFFFF;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2321533\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h42900000010000FF;
-    ans = 64'h4350010000001000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2322147\n");
-    end
-    x = 64'hC3D000800007FFFE;
-    y = 64'hBEBFFFFFFFFFF5FF;
-    z = 64'hC01FFFFF7FF00000;
-    ans = 64'h42A000800007EAFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2322761\n");
-    end
-    x = 64'h41EF6DB877E81671;
-    y = 64'h4000000000000000;
-    z = 64'hC000000000000000;
-    ans = 64'h41FF6DB877C81671;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2323375\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h7FD0080007FFFFFE;
-    z = 64'hC4B001FFFFFFFE00;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2323989\n");
-    end
-    x = 64'h407000400003FFFF;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hFFF0000100003FFF;
-    ans = 64'hFFF8000100003FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2324603\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hFFF003FFFFFFFF7E;
-    z = 64'h3CA0000000000000;
-    ans = 64'hFFF803FFFFFFFF7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2325217\n");
-    end
-    x = 64'hBFE000000000013F;
-    y = 64'h47AFFE001FFFFFFF;
-    z = 64'h4005F18C2B986B5B;
-    ans = 64'hC79FFE002000027D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2325831\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h4010000000000000;
-    z = 64'hBFD0000000000000;
-    ans = 64'h4360000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2326445\n");
-    end
-    x = 64'hC34FEFFFFFFFFFEE;
-    y = 64'hC02001FFFFFFFEFE;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2327059\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h3F9040FFFFFFFFFF;
-    ans = 64'h4370000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2327673\n");
-    end
-    x = 64'h37EFFFFDFFEFFFFE;
-    y = 64'hBFB00000027FFFFE;
-    z = 64'hC34002000000003F;
-    ans = 64'hC34002000000003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2328287\n");
-    end
-    x = 64'h403873F06862F88A;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hBFF0000000000001;
-    ans = 64'h406853F06862F888;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2328901\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hC3DFFFFFFFFFF700;
-    z = 64'h47F297807F5E74B8;
-    ans = 64'h47F296807F5E74B8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2329515\n");
-    end
-    x = 64'hC3FFFFFE00FFFFFF;
-    y = 64'h4340000000000001;
-    z = 64'h41C6C1CE73976263;
-    ans = 64'hC74FFFFE01000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2330129\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h400DAAF23F993605;
-    z = 64'h0010000000000001;
-    ans = 64'h435DAAF23F993607;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2330743\n");
-    end
-    x = 64'hAFFFFFFFFFF7FF00;
-    y = 64'h002FFFFF80000200;
-    z = 64'h3F0E34BFD440A8BC;
-    ans = 64'h3F0E34BFD440A8BC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2331357\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hBCA0000000000001;
-    ans = 64'h46A0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2331971\n");
-    end
-    x = 64'hCAEFFFFFFFFF0FFF;
-    y = 64'h3F0FFFFFFFCFFFFE;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'hCA0FFFFFFFCF0FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2332585\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h7FE0000000000001;
-    z = 64'hA5B07DFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2333199\n");
-    end
-    x = 64'h41F0000100003FFF;
-    y = 64'h3CAFFFFFFFE001FE;
-    z = 64'hC02FFFF8000000FF;
-    ans = 64'hC02FFFF7DFFFFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2333813\n");
-    end
-    x = 64'h7FF0011FFFFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'h7FF8011FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2334427\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hC010010000000000;
-    z = 64'h4033FFFFFFFFFFFE;
-    ans = 64'hC36000FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2335041\n");
-    end
-    x = 64'hB2D5935872999FF4;
-    y = 64'h7FF0000000000000;
-    z = 64'h401000000081FFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2335655\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hC06066C8FFE71609;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hC3B066C8FFE7160A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2336269\n");
-    end
-    x = 64'h3FD0004000000000;
-    y = 64'h38A0000000030000;
-    z = 64'hADF07FFFFC000000;
-    ans = 64'h388000400003000C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2336883\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2337497\n");
-    end
-    x = 64'h14C000004007FFFF;
-    y = 64'h37FFFFFFFF87FFFF;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2338111\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h8000000000000000;
-    z = 64'h43D72945D1D10C0A;
-    ans = 64'h43D72945D1D10C0A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2338725\n");
-    end
-    x = 64'h6CEFFFFDFFFFFBFF;
-    y = 64'hCF45787D5C8AEF60;
-    z = 64'h39C0003FFFDFFFFF;
-    ans = 64'hFC45787C050316E8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2339339\n");
-    end
-    x = 64'hB925E77B943E3684;
-    y = 64'h8000000000000001;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2339953\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hBC2003FFFFFFFFFE;
-    z = 64'h381FFFFFFFD00000;
-    ans = 64'hBF7003FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2340567\n");
-    end
-    x = 64'h3FFFFBFEFFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h4034A12AB8ACFA1E;
-    ans = 64'h4034A12AB8ACFA1E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2341181\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h3FE07FFFFFFFFFF0;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2341795\n");
-    end
-    x = 64'h434890F6EC8A3B10;
-    y = 64'h401FFFFFFFF0000F;
-    z = 64'hC7FFEFFFFFFFFFFC;
-    ans = 64'hC7FFEFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2342409\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h8010000000000001;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h8360000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2343023\n");
-    end
-    x = 64'hC0F0000000200003;
-    y = 64'hC3CFFC0000007FFF;
-    z = 64'h4010000000000000;
-    ans = 64'h44CFFC0000407805;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2343637\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h334F7FFBFFFFFFFE;
-    ans = 64'h334F7FFBFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2344251\n");
-    end
-    x = 64'hC3C00000003FFFFF;
-    y = 64'h38C0000000FFFBFF;
-    z = 64'hB80624BD323C64F9;
-    ans = 64'hBC900000013FFBFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2344865\n");
-    end
-    x = 64'hC1F00000000000FB;
-    y = 64'hBCA0000000000000;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFCFFFFC00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2345479\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h3FFBFFFFFFFFFFEF;
-    z = 64'hC01FF800000003FF;
-    ans = 64'h434BFFFFFFFFFFED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2346093\n");
-    end
-    x = 64'h41EAD27A45E8198B;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h9660000001FFFFEE;
-    ans = 64'hBEAAD27A45E8198A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2346707\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h17CFDFFFFFFFFFFC;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2347321\n");
-    end
-    x = 64'h800FFFFFF7FDFFFF;
-    y = 64'h3E2FFF7BFFFFFFFF;
-    z = 64'h4AC1FFEFFFFFFFFF;
-    ans = 64'h4AC1FFEFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2347935\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hBFD0000000000000;
-    z = 64'h8000000000000000;
-    ans = 64'hC320000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2348549\n");
-    end
-    x = 64'hCF5FFFFFFFEFE000;
-    y = 64'hC023FFFFFFE00000;
-    z = 64'h4000000000000001;
-    ans = 64'h4F93FFFFFFD5EC00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2349163\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hC7FFFFE1FFFFFFFF;
-    ans = 64'hC7FFFFE1FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2349777\n");
-    end
-    x = 64'hC51FFC00000FFFFF;
-    y = 64'hC1D7FFFFFFFFF7FE;
-    z = 64'hB8C0500000000000;
-    ans = 64'h4707FD00000BF7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2350391\n");
-    end
-    x = 64'h3FED5F03FF053628;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBFDD5F03FF053628;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2351005\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h37ECFFFFFFFFFFFE;
-    z = 64'h3CFFDFFFFFFFFFFE;
-    ans = 64'h3CFFE00001CFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2351619\n");
-    end
-    x = 64'h445FFFFFF8000007;
-    y = 64'hBFE0000000000001;
-    z = 64'h41F528D1252D9058;
-    ans = 64'hC44FFFFFF7FF56C2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2352233\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h41FE7CFA871C6E01;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2352847\n");
-    end
-    x = 64'hFFD00FFFFFFFFFFC;
-    y = 64'h401FFEF000000000;
-    z = 64'hC69FFFFFFFF001FF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2353461\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2354075\n");
-    end
-    x = 64'h3FF0400001FFFFFF;
-    y = 64'hBFB00000010000FF;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h3FFEFBFFFFCFBFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2354689\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hBFF0000000000001;
-    z = 64'hBFE0000010FFFFFF;
-    ans = 64'hC340000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2355303\n");
-    end
-    x = 64'hC3409FFFFFFFFFFE;
-    y = 64'hFFFFFFF7FFFFFFBE;
-    z = 64'h41D71184951FDAC6;
-    ans = 64'hFFFFFFF7FFFFFFBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2355917\n");
-    end
-    x = 64'hBFE000003BFFFFFE;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h3FF000003BFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2356531\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h30D07FFF80000000;
-    z = 64'hC34FFFF00001FFFE;
-    ans = 64'hC34FFFF00001FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2357145\n");
-    end
-    x = 64'h3FC000002000000F;
-    y = 64'hC000000000000000;
-    z = 64'h43D00000001F7FFF;
-    ans = 64'h43D00000001F7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2357759\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h3FDFFF0000001000;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC348003FFFFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2358373\n");
-    end
-    x = 64'h48001FFFFFFFFFFC;
-    y = 64'h3F32E0A31D93728A;
-    z = 64'hBFFFFFFFFF003FFF;
-    ans = 64'h4743066463CE996A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2358987\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2359601\n");
-    end
-    x = 64'hCDFFFFFFF00000FE;
-    y = 64'h5ECF800007FFFFFE;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'hECDF7FFFF84000F4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2360215\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h7FE00003FFFFC000;
-    ans = 64'h7FE00003FFFFC000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2360829\n");
-    end
-    x = 64'h34C20BA1CFD35142;
-    y = 64'h40102003FFFFFFFF;
-    z = 64'h47E03FFFFFFFFFFF;
-    ans = 64'h47E03FFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2361443\n");
-    end
-    x = 64'h3FBF19DC6F82A36E;
-    y = 64'hC010000000000001;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hBFDF19DC6F82A370;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2362057\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h8D6A9D993D1D2C6E;
-    z = 64'hB9A3089D3E427A9F;
-    ans = 64'hB9A3089D3E427A9F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2362671\n");
-    end
-    x = 64'hC3D0000100000001;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h44CFFF8040000000;
-    ans = 64'h44D0004020080000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2363285\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'h7FD8140C75BE2D61;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2363899\n");
-    end
-    x = 64'hFFFFE00000002000;
-    y = 64'h41F813AD63F0CC13;
-    z = 64'h802FFFFFFFF7FFC0;
-    ans = 64'hFFFFE00000002000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2364513\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hC340000000000001;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'hC690000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2365127\n");
-    end
-    x = 64'hBCB58BA32DF145E0;
-    y = 64'h3FBE0000003FFFFF;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2365741\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hBDD3EF62FAA25F5B;
-    ans = 64'hC6A0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2366355\n");
-    end
-    x = 64'hC7EFFFFFFFFEFFDE;
-    y = 64'hBFC10003FFFFFFFE;
-    z = 64'hFFDFFFFFFFFFF000;
-    ans = 64'hFFDFFFFFFFFFF000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2366969\n");
-    end
-    x = 64'hDF2FFFFF800000FE;
-    y = 64'hFFE0000000000000;
-    z = 64'h8000000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2367583\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hBE8ADC8A28E4158C;
-    z = 64'h3FFFFFFFFFFEEFFF;
-    ans = 64'hC1DADC8A2864158E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2368197\n");
-    end
-    x = 64'hCF4FE0FFFFFFFFFE;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h38CD934899ED1CBD;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2368811\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hFFEFFF800001FFFF;
-    z = 64'hC010000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2369425\n");
-    end
-    x = 64'h402FFC00000000FF;
-    y = 64'h3CAFFFFFFEFFFFF6;
-    z = 64'hC3F0000803FFFFFF;
-    ans = 64'hC3F0000803FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2370039\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hFFF0000000000000;
-    z = 64'h4340000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2370653\n");
-    end
-    x = 64'hC3DFFFFFFBDFFFFF;
-    y = 64'hFFF0000040080000;
-    z = 64'h3FD0000000000001;
-    ans = 64'hFFF8000040080000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2371267\n");
-    end
-    x = 64'h4340000000000001;
-    y = 64'hFFF0000000000001;
-    z = 64'h7D5FFDFF7FFFFFFF;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2371881\n");
-    end
-    x = 64'h4000007FFFFFFF7E;
-    y = 64'h3FDCACB54358D66E;
-    z = 64'hFFD07FFFFFFFFFFA;
-    ans = 64'hFFD07FFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2372495\n");
-    end
-    x = 64'hBFE1329CAFA09F26;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h7FF0000000000001;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2373109\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBF97E2B472C87667;
-    z = 64'hBFDDFC0000000000;
-    ans = 64'hC2F7E2B472C8766E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2373723\n");
-    end
-    x = 64'hC3CB5CC56722BF2E;
-    y = 64'h0000000000000001;
-    z = 64'h4347A6A653DCE7C6;
-    ans = 64'h4347A6A653DCE7C6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2374337\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h80200000000001DF;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2374951\n");
-    end
-    x = 64'hC0B000000E000000;
-    y = 64'hC7EFF7BFFFFFFFFF;
-    z = 64'hBBA001FFFFFFFEFF;
-    ans = 64'h48AFF7C01BF8C7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2375565\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2376179\n");
-    end
-    x = 64'h47FBAFD5DD1373A4;
-    y = 64'h41C00000000003FB;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h49CBAFD5DD137A87;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2376793\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h0010000000000000;
-    z = 64'hB7EA274BBE534719;
-    ans = 64'hB7EA274BBE534719;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2377407\n");
-    end
-    x = 64'h3F7FFFFFFFF80FFF;
-    y = 64'hB7E0000000400020;
-    z = 64'h43E0000200000000;
-    ans = 64'h43E0000200000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2378021\n");
-    end
-    x = 64'hC3EBFFFFFFFFFFFB;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2378635\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h402FFF7FFFF00000;
-    z = 64'hFFDDFFFFFF7FFFFE;
-    ans = 64'hFFDDFFFFFF7FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2379249\n");
-    end
-    x = 64'hC7ED8AB087F5C05B;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h3FB7FFFFFFFF7FFF;
-    ans = 64'h3FB7FFFFFFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2379863\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h3F00080002000000;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'h4260080001FFBFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2380477\n");
-    end
-    x = 64'h402020000001FFFF;
-    y = 64'hBFDFFFFFFFBBFFFF;
-    z = 64'hC03F214815D6A0C8;
-    ans = 64'hC04194A40AE747E4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2381091\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2381705\n");
-    end
-    x = 64'h47FD9D82C52C1E71;
-    y = 64'h801FFFFFFFC0001F;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h882D9D82C4F0E388;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2382319\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h802DCFE0F56C6C8F;
-    ans = 64'h400FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2382933\n");
-    end
-    x = 64'hC3C000000000203F;
-    y = 64'h41CFFFFFEFFFFDFF;
-    z = 64'h179FFFFFFFFFBF7F;
-    ans = 64'hC59FFFFFF0003E7D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2383547\n");
-    end
-    x = 64'h401FFFFFFFFE1FFF;
-    y = 64'h3FD0000000000001;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2384161\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h3FBFFFFFFFFFFFC3;
-    z = 64'hC04DFFFE00000000;
-    ans = 64'h431FFFFFFFFFFED2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2384775\n");
-    end
-    x = 64'h47DFFFFF7DFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h47FFF00001FFFFFE;
-    ans = 64'h4801F7FFF8DFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2385389\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h44FFFFFFEFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h485FFFFFEFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2386003\n");
-    end
-    x = 64'hBF9FFFFFBFFFFFBF;
-    y = 64'h406FFFFFFFC01FFF;
-    z = 64'h3FFFFDFFFFFFFF00;
-    ans = 64'hC018007FBFC01FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2386617\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h3FE0000000000001;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2387231\n");
-    end
-    x = 64'h4370003FFFFFFEFE;
-    y = 64'h41C4C250A2F4F548;
-    z = 64'h0010000000000000;
-    ans = 64'h4544C2A3AC377FCD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2387845\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h411FDFDFFFFFFFFF;
-    ans = 64'h435000000001FDFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2388459\n");
-    end
-    x = 64'hC065E9EF4F9D3E21;
-    y = 64'hFFDE0F6202282F1D;
-    z = 64'hC0906DD67E9476DC;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2389073\n");
-    end
-    x = 64'hBFED82E3C6C037DB;
-    y = 64'h3FF0000000000000;
-    z = 64'h4340000000000000;
-    ans = 64'h433FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2389687\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hC020004000003FFF;
-    z = 64'hBA8FFF80000003FF;
-    ans = 64'hC380004000003FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2390301\n");
-    end
-    x = 64'h3FFC000000000800;
-    y = 64'h3FF0000000000001;
-    z = 64'h43EFFC0000003FFF;
-    ans = 64'h43EFFC0000003FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2390915\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h40200000200000FE;
-    z = 64'hBFE0000000000000;
-    ans = 64'h43800000200000FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2391529\n");
-    end
-    x = 64'h401FFFFFFDEFFFFF;
-    y = 64'hBEBFFFFFFDFDFFFF;
-    z = 64'hBFBFFFFFFFC0007F;
-    ans = 64'hBFC0007FFFDFEFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2392143\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h4000000000000000;
-    z = 64'h3FF0000000000000;
-    ans = 64'h435FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2392757\n");
-    end
-    x = 64'hC3DFFFFFFD7FFFFE;
-    y = 64'hC1C7D668CDFFE997;
-    z = 64'h0000000000000001;
-    ans = 64'h45B7D668CC232965;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2393371\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h4000000000000001;
-    z = 64'h9010FFFFFFFEFFFF;
-    ans = 64'h4360000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2393985\n");
-    end
-    x = 64'h000FFC1FFFFFFFFF;
-    y = 64'h3FBFFFFFF0001FFF;
-    z = 64'h01A54E0A36E764E7;
-    ans = 64'h01A54E0A37E726E7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2394599\n");
-    end
-    x = 64'hB80FFFFFFFFFFFFE;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2395213\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBFF3FFF7FFFFFFFF;
-    z = 64'hC7FD05FDFF73E632;
-    ans = 64'hC7FD05FDFF73E632;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2395827\n");
-    end
-    x = 64'h800FFFFFFFFFBFDE;
-    y = 64'h4010000000000000;
-    z = 64'h55B0AE982E8F89CC;
-    ans = 64'h55B0AE982E8F89CC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2396441\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h3FAF000100000000;
-    z = 64'hBFD0000000000001;
-    ans = 64'h430F0000FFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2397055\n");
-    end
-    x = 64'hBFD001FFFFFFDFFF;
-    y = 64'hBE4FFFFFFE03FFFE;
-    z = 64'hFFE2BDEF6A61D7BE;
-    ans = 64'hFFE2BDEF6A61D7BE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2397669\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h3FE0000000000001;
-    ans = 64'h437FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2398283\n");
-    end
-    x = 64'hFFFEEFB34C4329A7;
-    y = 64'h44AFFFFFFFFFFFFE;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2398897\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h4340000000000000;
-    z = 64'hBEFF00000000007E;
-    ans = 64'h469FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2399511\n");
-    end
-    x = 64'h002B563D959D14CC;
-    y = 64'h40F3396D3630BF96;
-    z = 64'h43DFFFFFFFFDFE00;
-    ans = 64'h43DFFFFFFFFDFE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2400125\n");
-    end
-    x = 64'h800FFFFFFFFBF7FE;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2400739\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hB814A433BE51486C;
-    z = 64'hF26000087FFFFFFF;
-    ans = 64'hF26000087FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2401353\n");
-    end
-    x = 64'h40000000001003FF;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hBFF00040000001FF;
-    ans = 64'h43600000001003FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2401967\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hC8000800007FFFFF;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hCB600800007FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2402581\n");
-    end
-    x = 64'hB80393169FC8A232;
-    y = 64'hC0178CD9F52F1A10;
-    z = 64'h3E508001FFFFFFFF;
-    ans = 64'h3E508001FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2403195\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2403809\n");
-    end
-    x = 64'hC3FF002000000000;
-    y = 64'hC012B1E30F60CDD3;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2404423\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hC06D84BF2BB77CB8;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2405037\n");
-    end
-    x = 64'hC0200003FFFFBFFE;
-    y = 64'hC060007FFFFFBFFE;
-    z = 64'h37EFFFBFFFFFFFF6;
-    ans = 64'h40900084001F7FFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2405651\n");
-    end
-    x = 64'hBFCFE0000000000F;
-    y = 64'h7FF0000000000001;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2406265\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBFDFD933B5463C94;
-    z = 64'hC1F200000000003F;
-    ans = 64'hC33FD934D5463C93;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2406879\n");
-    end
-    x = 64'h47FFFFFFFF800003;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h43DFFFFE0000FFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2407493\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBCA0001FF0000000;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'hC000001FEFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2408107\n");
-    end
-    x = 64'h3F8FFFFFFDFFFEFE;
-    y = 64'hFFE004000000001F;
-    z = 64'hFFE003FFFFFFFFFB;
-    ans = 64'hFFE0440FFFFBFEF9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2408721\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h8000000000000001;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2409335\n");
-    end
-    x = 64'hC1F000000000001F;
-    y = 64'hC00103FFFFFFFFFF;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2409949\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hCDC00200003FFFFE;
-    ans = 64'hCDC00200003FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2410563\n");
-    end
-    x = 64'hC1CFFFF800001FFF;
-    y = 64'h7FEFFFFFFFF07FFF;
-    z = 64'h47E02DD4EE6F16D6;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2411177\n");
-    end
-    x = 64'h3E53A6C3B8E56152;
-    y = 64'h8010000000000000;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2411791\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hC7EEFFFFFFFFFFBE;
-    z = 64'h3FF20000000FFFFF;
-    ans = 64'hCB4EFFFFFFFFFFBD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2412405\n");
-    end
-    x = 64'h402FFFF80FFFFFFF;
-    y = 64'h8010000000000001;
-    z = 64'hC1437E9173E00C82;
-    ans = 64'hC1437E9173E00C82;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2413019\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hB810008000001FFE;
-    z = 64'h8010000000000000;
-    ans = 64'hBB70008000001FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2413633\n");
-    end
-    x = 64'hC001FFE4B8134224;
-    y = 64'hBFD0000000037FFF;
-    z = 64'h7FE20000FFFFFFFF;
-    ans = 64'h7FE20000FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2414247\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBCA0000000000000;
-    z = 64'h3CA0000000000000;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2414861\n");
-    end
-    x = 64'h3FEFFF7FFFFFFEFF;
-    y = 64'h8020002000000006;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2415475\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBCA0000000000001;
-    z = 64'hB57FFFFFFC00000E;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2416089\n");
-    end
-    x = 64'hBFCFFFFFFFE003FE;
-    y = 64'hC190004004000000;
-    z = 64'h02502E98C105274C;
-    ans = 64'h4170004003F001BF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2416703\n");
-    end
-    x = 64'h3FDFFFFFFFFF7000;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2417317\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h683905CF5187CAA5;
-    z = 64'hC030000800000007;
-    ans = 64'h6B9905CF5187CAA4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2417931\n");
-    end
-    x = 64'hCC107FF000000000;
-    y = 64'hBFD0000000000000;
-    z = 64'h4507B3BFBB78EFE5;
-    ans = 64'h4BF07FF000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2418545\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hC07002000000003F;
-    z = 64'h8000000000000001;
-    ans = 64'hC3D002000000003E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2419159\n");
-    end
-    x = 64'h401000041FFFFFFE;
-    y = 64'hC34AB555D6DB3D20;
-    z = 64'hB71FF800000007FE;
-    ans = 64'hC36AB55CB99B5E81;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2419773\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h0010000000000001;
-    ans = 64'hC33FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2420387\n");
-    end
-    x = 64'hC030007FFFFC0000;
-    y = 64'hBFDFFFFFE07FFFFE;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'h3F4FFC0EE07FE0FA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2421001\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBFE0000000000000;
-    z = 64'hC1DFC00000000002;
-    ans = 64'hC34000003F800000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2421615\n");
-    end
-    x = 64'h8000000002000000;
-    y = 64'hFF100001EFFFFFFF;
-    z = 64'h8D261BB2DA873976;
-    ans = 64'h3D800001EFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2422229\n");
-    end
-    x = 64'hC3F0EC7428A39224;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h43F0EC7428A39223;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2422843\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFF82;
-    z = 64'h0011114A361594FC;
-    ans = 64'hC00FFFFFFFFFFF81;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2423457\n");
-    end
-    x = 64'h3FD0FBBF78309F71;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h61EFF7FFFFFBFFFF;
-    ans = 64'h61EFF7FFFFFBFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2424071\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h3FF28976C15F0778;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2424685\n");
-    end
-    x = 64'h480FFFFFFFFFFFFF;
-    y = 64'h3FF42A8ADCFAE94E;
-    z = 64'h418000005FFFFFFE;
-    ans = 64'h48142A8ADCFAE94D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2425299\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hC35FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2425913\n");
-    end
-    x = 64'hC03502AC87DDF103;
-    y = 64'h3FA5997EC022603A;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC0138BA24EB04DDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2426527\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h3B2000010000007F;
-    ans = 64'hC35FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2427141\n");
-    end
-    x = 64'h4026288FEF6695C2;
-    y = 64'hC032000000000200;
-    z = 64'hC1EF6A05D4EDE99D;
-    ans = 64'hC1EF6A05EDDB8B8A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2427755\n");
-    end
-    x = 64'h4010007FFFFBFFFF;
-    y = 64'hC000000000000001;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'hC020007FFFFC0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2428369\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hC05FFF7FFFFFBFFE;
-    z = 64'hBFBFFF7FE0000000;
-    ans = 64'hC3BFFF7FFFFFBFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2428983\n");
-    end
-    x = 64'h7FE61B8FDFDDBD73;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hC7FFF807FFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2429597\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h4010000000088000;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2430211\n");
-    end
-    x = 64'hC3D000077FFFFFFE;
-    y = 64'h4760000000103FFF;
-    z = 64'hC02FFFFFFFE00002;
-    ans = 64'hCB40000780104005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2430825\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hC010000000000000;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2431439\n");
-    end
-    x = 64'h42D020001FFFFFFF;
-    y = 64'hCD1D000A016615E8;
-    z = 64'hC000000000000000;
-    ans = 64'hCFFD3A0A4F68F615;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2432053\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hBF7FFFFF7FC00000;
-    ans = 64'hC37FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2432667\n");
-    end
-    x = 64'h480F4C07FE7541A5;
-    y = 64'h3FCFFFFFFF7FFFEE;
-    z = 64'h2DBFFFFBFFBFFFFF;
-    ans = 64'h47EF4C07FDF81173;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2433281\n");
-    end
-    x = 64'hBFEFFFC00000003F;
-    y = 64'hC340000000000000;
-    z = 64'h3CA0000000000000;
-    ans = 64'h433FFFC00000003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2433895\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hC3EFFDFFFFF80000;
-    z = 64'hAC9E00003FFFFFFF;
-    ans = 64'hC74FFDFFFFF7FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2434509\n");
-    end
-    x = 64'hB1B00000001001FF;
-    y = 64'hC340000000000001;
-    z = 64'h3FDFFFFFFFEFFFFC;
-    ans = 64'h3FDFFFFFFFEFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2435123\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'h48000000000000FA;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2435737\n");
-    end
-    x = 64'hC1F0000000005FFF;
-    y = 64'hC3D000000007C000;
-    z = 64'h38180000000000FE;
-    ans = 64'h45D0000000081FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2436351\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2436965\n");
-    end
-    x = 64'h44CFFF0001FFFFFE;
-    y = 64'h39E20528C2077414;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFEFFFFB7ED9D98A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2437579\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hFFE0000000000001;
-    z = 64'h400FFFFFFFFFF7EF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2438193\n");
-    end
-    x = 64'hB9617FFFFFFFFFFF;
-    y = 64'hC0183814DE8DA0F4;
-    z = 64'h4650000000208000;
-    ans = 64'h4650000000208000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2438807\n");
-    end
-    x = 64'h9870000401FFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h0010000000000001;
-    ans = 64'h5870000401FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2439421\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBFC00200001FFFFE;
-    z = 64'hC03000000043FFFE;
-    ans = 64'hC32002000020001D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2440035\n");
-    end
-    x = 64'h2E4FFFFFFF8007FF;
-    y = 64'hFFF0000000000000;
-    z = 64'hC2A04000000FFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2440649\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hBE21FC0000000000;
-    z = 64'h4340000000000001;
-    ans = 64'h433FFFFFFDC08002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2441263\n");
-    end
-    x = 64'hC1D80000007FFFFF;
-    y = 64'hBFD00000400000FE;
-    z = 64'h215FEDFFFFFFFFFF;
-    ans = 64'h41B800006080017E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2441877\n");
-    end
-    x = 64'h434FFFFFFFFFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2442491\n");
-    end
-    x = 64'h7FD20000001FFFFE;
-    y = 64'hFA7FFBFFDFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2443105\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h0000000000000000;
-    z = 64'hC3D1DD612FB617A3;
-    ans = 64'hC3D1DD612FB617A3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2443719\n");
-    end
-    x = 64'hC3CFDFFFFFFEFFFF;
-    y = 64'hB7FFDFFFFFFBFFFE;
-    z = 64'h400FFF7FFFFEFFFE;
-    ans = 64'h400FFF7FFFFEFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2444333\n");
-    end
-    x = 64'h37E0000100004000;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h000FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2444947\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h3FCFFFFFFFF0007E;
-    z = 64'hB1FFFFFFF0000003;
-    ans = 64'h432FFFFFFFF0007C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2445561\n");
-    end
-    x = 64'h3FF36ED15DD5FF0B;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h40EFDEFFFFFFFFFE;
-    ans = 64'h40EFDEFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2446175\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h43D00001FFFFFFFE;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h47300001FFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2446789\n");
-    end
-    x = 64'hC03FE0003FFFFFFF;
-    y = 64'hB7EFFFF7FFEFFFFF;
-    z = 64'hC000000FF7FFFFFE;
-    ans = 64'hC000000FF7FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2447403\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h0010000000000001;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2448017\n");
-    end
-    x = 64'hC3C0FFFFFFFFDFFE;
-    y = 64'hA5900000080003FF;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2448631\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h400FFFFFEFFFFFF7;
-    ans = 64'h400FFFFFEFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2449245\n");
-    end
-    x = 64'h0020000000110000;
-    y = 64'h6D2F133A7F2809C1;
-    z = 64'hC03000000001FFFC;
-    ans = 64'hC03000000001FFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2449859\n");
-    end
-    x = 64'h3FB1518817833EC0;
-    y = 64'h3CA0000000000000;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2450473\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hC67FFFFFC0000800;
-    z = 64'h4034000000007FFE;
-    ans = 64'hC9DFFFFFC00007FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2451087\n");
-    end
-    x = 64'h3FCFF00003FFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h40396641E9D46149;
-    ans = 64'h40396641E9D46149;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2451701\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h7FF19D6663608B5D;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h7FF99D6663608B5D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2452315\n");
-    end
-    x = 64'h7FDFFFFFFC07FFFF;
-    y = 64'h41CFFFFC01FFFFFE;
-    z = 64'hCA40001FFFF7FFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2452929\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h3FD0000000000000;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'h432FFFFFFFFFFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2453543\n");
-    end
-    x = 64'hB7F00003FFFFE000;
-    y = 64'h3FCF7F2EBA57F364;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2454157\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h405C0023F12D5E3D;
-    ans = 64'h4340000000000037;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2454771\n");
-    end
-    x = 64'h7FD004007FFFFFFF;
-    y = 64'hC020000000008001;
-    z = 64'hC80BDBDBDC204CF5;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2455385\n");
-    end
-    x = 64'h480EFB187297B81E;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2455999\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h43F00B8D04784AC1;
-    z = 64'h3FBFFFFFEE000000;
-    ans = 64'h47500B8D04784AC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2456613\n");
-    end
-    x = 64'hCC6FFF8000000001;
-    y = 64'h3FE0000000000001;
-    z = 64'hBFA27E00240AF10F;
-    ans = 64'hCC5FFF8000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2457227\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hC1FFFF0FFFFFFFFF;
-    z = 64'h4000000000000000;
-    ans = 64'hC55FFF0FFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2457841\n");
-    end
-    x = 64'h40AFFFFFFFFFFCFE;
-    y = 64'h380000000000017F;
-    z = 64'h000E30BD8369AC4B;
-    ans = 64'h38BFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2458455\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hC010000000000000;
-    ans = 64'h434FFFFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2459069\n");
-    end
-    x = 64'h7FEFFFFFFEFFFFBF;
-    y = 64'h401FBFFFFC000000;
-    z = 64'hBCA0000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2459683\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h3FF0000000000001;
-    z = 64'hFFD7E4BB7A2E0326;
-    ans = 64'hFFD7E4BB7A2E0326;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2460297\n");
-    end
-    x = 64'h45EE2D3BC6E262EA;
-    y = 64'h37FFFFFFFF7FFEFF;
-    z = 64'h3FD774F0EF62E768;
-    ans = 64'h3FD774F0EFDB9C57;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2460911\n");
-    end
-    x = 64'h3F3F7FFFF8000000;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2461525\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h4C7FFFFFF7FFFFFE;
-    z = 64'hC010000000800100;
-    ans = 64'h4FDFFFFFF7FFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2462139\n");
-    end
-    x = 64'hC010100001000000;
-    y = 64'h4000000000000000;
-    z = 64'hC07FFFFFFF7FFEFF;
-    ans = 64'hC080403FFFC3FF80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2462753\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h47EFFFFFFFFF7F80;
-    z = 64'h3FF0000000000001;
-    ans = 64'h4B4FFFFFFFFF7F7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2463367\n");
-    end
-    x = 64'h3FCD3AEC7123E6D4;
-    y = 64'hC040FFFFFFFFFFFF;
-    z = 64'h41700008000FFFFE;
-    ans = 64'h4170000783D5931D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2463981\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hC000000000000001;
-    ans = 64'h436FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2464595\n");
-    end
-    x = 64'h270F000000FFFFFF;
-    y = 64'h41CE3457B589E945;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h28ED42B4F8CF3CB8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2465209\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h4010000000000000;
-    z = 64'hC03FFBFFF0000000;
-    ans = 64'h436FFFFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2465823\n");
-    end
-    x = 64'hC3D00003FEFFFFFF;
-    y = 64'hB7EFFFFFFFFFF001;
-    z = 64'h3FF0400000000001;
-    ans = 64'h3FF0400000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2466437\n");
-    end
-    x = 64'h78B000000203FFFF;
-    y = 64'h4010000000000001;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'h78D0000002040000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2467051\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h41CFFFF3FFFFFFFF;
-    z = 64'h38FFFFFFFFFFFF82;
-    ans = 64'h452FFFF3FFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2467665\n");
-    end
-    x = 64'hBFF76194103CAB16;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hFFE0BFFFFFFFFFFE;
-    ans = 64'hFFE0BFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2468279\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h401003FEFFFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h437003FEFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2468893\n");
-    end
-    x = 64'hC1000F8D71DACA50;
-    y = 64'h7BD00000000047FF;
-    z = 64'h434836306FD629E2;
-    ans = 64'hFCE00F8D71DB1295;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2469507\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h4340000000000001;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'h46A0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2470121\n");
-    end
-    x = 64'h8BC20000000001FE;
-    y = 64'h47F0000FFFFDFFFF;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h93C20011FFFDC1FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2470735\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hC01E007FFFFFFFFF;
-    ans = 64'h46AFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2471349\n");
-    end
-    x = 64'hC34FFFFFFFFFFC00;
-    y = 64'hBBE000000000027F;
-    z = 64'h43DFFFFFEFFFFBFF;
-    ans = 64'h43DFFFFFEFFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2471963\n");
-    end
-    x = 64'h381E94E42BF42E17;
-    y = 64'h7FE0000000000000;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'h780E94E42BF42E17;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2472577\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hC0600000021FFFFF;
-    z = 64'h387007FFFFFFFFFA;
-    ans = 64'hC3C00000021FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2473191\n");
-    end
-    x = 64'hC1FFFFFFFE1FFFFE;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hB7FFFFFFFBFFFFBF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2473805\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h766C7FFFFFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h79CC7FFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2474419\n");
-    end
-    x = 64'hC34FFFFFFFFFFC07;
-    y = 64'hB810000200001000;
-    z = 64'hC7A000000000004E;
-    ans = 64'hC7A000000000004E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2475033\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h7FF0000000000000;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2475647\n");
-    end
-    x = 64'hBFEFE00008000000;
-    y = 64'hCE7000FFFFFBFFFE;
-    z = 64'h8000000000000000;
-    ans = 64'h4E6FE1FE07F887FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2476261\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h40DFFFFC00020000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2476875\n");
-    end
-    x = 64'h2CFFFFFFEE000000;
-    y = 64'hBCAFFFFFFBFFFF80;
-    z = 64'hE29FFFFE000FFFFF;
-    ans = 64'hE29FFFFE000FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2477489\n");
-    end
-    x = 64'h3C70000001FFFFFA;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'hC010000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2478103\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h417F8000000003FF;
-    z = 64'h41CFFFFFFFFDFFFF;
-    ans = 64'h44DF80000000040D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2478717\n");
-    end
-    x = 64'hBC0FF000000007FF;
-    y = 64'h8000000000000001;
-    z = 64'h40BFFFFDFFFFBFFF;
-    ans = 64'h40BFFFFDFFFFBFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2479331\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hC28FFFFFFFC00000;
-    z = 64'h3FD0000000000000;
-    ans = 64'hC5EFFFFFFFBFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2479945\n");
-    end
-    x = 64'hBFA080FFFFFFFFFF;
-    y = 64'h3D14FE4D81C77FAF;
-    z = 64'h3FC0C75B734A8881;
-    ans = 64'h3FC0C75B734A886B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2480559\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2481173\n");
-    end
-    x = 64'h000000001FEFFFFF;
-    y = 64'hC01FF80000000000;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2481787\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h8010000000000001;
-    z = 64'h4030003FFFFDFFFF;
-    ans = 64'h4030003FFFFDFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2482401\n");
-    end
-    x = 64'hD8A00004003FFFFF;
-    y = 64'h3F3FFFEF7FFFFFFF;
-    z = 64'hFFE008000000FFFE;
-    ans = 64'hFFE008000000FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2483015\n");
-    end
-    x = 64'hC1F0003EFFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2483629\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h47F2990F0D3AB431;
-    z = 64'h393D2F8E7A9FABB8;
-    ans = 64'h4B52990F0D3AB430;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2484243\n");
-    end
-    x = 64'h403000003FBFFFFF;
-    y = 64'hBCA0000000000000;
-    z = 64'hB81E0000001FFFFE;
-    ans = 64'hBCE000003FBFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2484857\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hC04FF800000003FF;
-    z = 64'h3CA0000000000001;
-    ans = 64'hC3AFF800000003FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2485471\n");
-    end
-    x = 64'hBF0C50CD67902869;
-    y = 64'h403BFFC000000000;
-    z = 64'h40A04000007FFFFF;
-    ans = 64'h40A03FFF3A4C2737;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2486085\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'hBFD0000000000001;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFD0000000000000;
     ans = 64'hC010FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2486699\n");
+    	$fwrite(fp,"1038257\n");
     end
-    x = 64'hFFDFBBFFFFFFFFFE;
-    y = 64'hBE9FFFFFF80007FF;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h9DE0000007FEFFFF;
+    ReadData2E = 64'hC3E001FFFFFF8000;
+    ReadData3E = 64'h400FFFFFAFFFFFFE;
+    ans = 64'h400FFFFFAFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2487313\n");
+    	$fwrite(fp,"1038563\n");
     end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hBFD0000000000000;
-    z = 64'hC1F0000080001000;
-    ans = 64'hC3300001000007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2487927\n");
-    end
-    x = 64'hC03FFBFFEFFFFFFE;
-    y = 64'hBD21FFFFFFFFFDFF;
-    z = 64'h43EF800040000000;
-    ans = 64'h43EF800040000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2488541\n");
-    end
-    x = 64'hB7F0000000024000;
-    y = 64'hBFD0000000000001;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2489155\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h000F800001FFFFFE;
-    z = 64'h47F00000007F8000;
-    ans = 64'h47F00000007F8000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2489769\n");
-    end
-    x = 64'h7FE244C23A3D6EAE;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h9B2FFFFFFFFFEDFF;
-    ans = 64'hFFD244C23A3D6EAD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2490383\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h4FA9881599BF1A5B;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h5309881599BF1A59;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2490997\n");
-    end
-    x = 64'h381FFFFFFFFFDEFF;
-    y = 64'h49CFBFF7FFFFFFFF;
-    z = 64'h3FE898FF0DEE5590;
-    ans = 64'h41FFBFF8000C2BC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2491611\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hBFE0000000000001;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2492225\n");
-    end
-    x = 64'hC0303FFFFFFFFE00;
-    y = 64'h7FDFFFFFEF7FFFFF;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2492839\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hBFBDFFFFFFFFFFDE;
-    ans = 64'hC34FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2493453\n");
-    end
-    x = 64'h3CA2DEE9CC137D78;
-    y = 64'hC340000000008000;
-    z = 64'h3C4A51233EDE3650;
-    ans = 64'hBFF2DEE9CC14146F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2494067\n");
-    end
-    x = 64'hC01C622D64A3288A;
-    y = 64'hBFF0000000000000;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h4018622D64A3288A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2494681\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h4030002000FFFFFE;
-    z = 64'h6C6000000007F800;
-    ans = 64'h6C6000000007F800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2495295\n");
-    end
-    x = 64'h97938A198628AFDE;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h3CA1FFFFFFFFDFFF;
-    ans = 64'h3CA1FFFFFFFFDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2495909\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h499FFFFFFFFEFFFE;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h4CFFFFFFFFFEFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2496523\n");
-    end
-    x = 64'hBFB71435A3DCB677;
-    y = 64'hBFBFFFF7FFFFFF7F;
-    z = 64'hC0503FFF7FFFFFFE;
-    ans = 64'hC0503F46DE810984;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2497137\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hC000000000000000;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'hC35FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2497751\n");
-    end
-    x = 64'hC033F17FAAA569B5;
-    y = 64'hC34EFFFFFFFFFFDE;
-    z = 64'h4340000000000000;
-    ans = 64'h4393D1F3AD503E52;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2498365\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h801FFFFFFFF7FFBE;
-    ans = 64'hC36FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2498979\n");
-    end
-    x = 64'h4B82DA79B78A7C5C;
-    y = 64'hFFF8F12536538EFF;
-    z = 64'hC01FFC0000000100;
-    ans = 64'hFFF8F12536538EFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2499593\n");
-    end
-    x = 64'hBB7F4BAC4BBA9910;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2500207\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h401FC147E4167F25;
-    z = 64'h407B43BA65F2A73B;
-    ans = 64'h437FC147E4167F3E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2500821\n");
-    end
-    x = 64'hBFDDD9E98A3D34F9;
-    y = 64'hC010000000000001;
-    z = 64'hC3DD470895062963;
-    ans = 64'hC3DD470895062963;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2501435\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h7FEFBFFFF7FFFFFF;
-    z = 64'h0000000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2502049\n");
-    end
-    x = 64'hC3FFFFFF000FFFFF;
-    y = 64'h7FF07FFFFFFE0000;
-    z = 64'h43CFFFFFFFFFDFFE;
-    ans = 64'h7FF87FFFFFFE0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2502663\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h8010000000000000;
-    ans = 64'hC37FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2503277\n");
-    end
-    x = 64'h7FF0000000FFBFFF;
-    y = 64'hA9A0001FFFFFFFF8;
-    z = 64'h4010000000000001;
-    ans = 64'h7FF8000000FFBFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2503891\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hC340000000000001;
-    z = 64'hBCA3FFFFFFFF7FFE;
-    ans = 64'hC6A0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2504505\n");
-    end
-    x = 64'h3D00800000000002;
-    y = 64'hC06FFFFFE00003FF;
-    z = 64'hB81CC3048B84E23F;
-    ans = 64'hBD807FFFEF800211;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2505119\n");
-    end
-    x = 64'h434FE0000007FFFF;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hBFD0000000000001;
-    ans = 64'hC6AFE0000007FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2505733\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hFFDFFEFEFFFFFFFF;
-    z = 64'h399D95938DB130F5;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2506347\n");
-    end
-    x = 64'h43FF0AD19973161F;
-    y = 64'hFFE0000000000000;
-    z = 64'h41E0000000002FFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2506961\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hC00FEFFFFFFFFDFF;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2507575\n");
-    end
-    x = 64'hBFC000107FFFFFFF;
-    y = 64'h380FBFFFFFFFFDFF;
-    z = 64'h43403FFFFFFF8000;
-    ans = 64'h43403FFFFFFF8000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2508189\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h8000000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2508803\n");
-    end
-    x = 64'hC0500003FFFFFEFE;
-    y = 64'hC2311EB7C65185DC;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h42911EBC0DFF865C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2509417\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'hFFF0000000000000;
-    z = 64'h90DFFFFFC3FFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2510031\n");
-    end
-    x = 64'hC1D866C6E8E78AA0;
-    y = 64'hBE0E00000007FFFF;
-    z = 64'hC0EFFFFEFFFFFFBE;
-    ans = 64'hC0EFFFD13F4B0B00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2510645\n");
-    end
-    x = 64'h001FFC000000FFFE;
-    y = 64'hFFF0000000000001;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2511259\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h364FFFFFF807FFFF;
-    z = 64'h400FFFFFFBFFFBFF;
-    ans = 64'h400FFFFFFBFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2511873\n");
-    end
-    x = 64'h7FEBFFDFFFFFFFFE;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h5A0FFFFEFFFF7FFF;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2512487\n");
-    end
-    x = 64'h434FFFFFFFFFFFFE;
-    y = 64'h497FFBFFFEFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2513101\n");
-    end
-    x = 64'hAC2000000200003E;
-    y = 64'h418FFFFDFFFFFBFF;
-    z = 64'h001FBFFFFFEFFFFF;
-    ans = 64'hADBFFFFE03FFFC3B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2513715\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h0000000000000001;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2514329\n");
-    end
-    x = 64'h001FFFFFFFFFFFE6;
-    y = 64'hC00FEFDFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2514943\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'hC0200005FFFFFFFF;
-    ans = 64'hC018000BFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2515557\n");
-    end
-    x = 64'h59F0000040003FFE;
-    y = 64'hC010003800000000;
-    z = 64'h57C1FEFFFFFFFFFF;
-    ans = 64'hDA10003840009007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2516171\n");
-    end
-    x = 64'hC3CFC00800000000;
-    y = 64'h0010000000000000;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h83EFC00800000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2516785\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hC03508327EAAA217;
-    z = 64'h3F700400000003FF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2517399\n");
-    end
-    x = 64'h2838382127EC1F47;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hC42FFFFC00000001;
-    ans = 64'hC42FFFFC00000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2518013\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h4B70000000400800;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2518627\n");
-    end
-    x = 64'h3FFF1FFFFFFFFFFF;
-    y = 64'h4140000000FFFFEE;
-    z = 64'h400FFFFFFFE1FFFE;
-    ans = 64'h414F200201F1FFDA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2519241\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h3CA0000000000000;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2519855\n");
-    end
-    x = 64'hBD2002FFFFFFFFFF;
-    y = 64'h802989E4FD4682E9;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2520469\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h47E8C5BFE3AE8110;
-    ans = 64'h7C9FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2521083\n");
-    end
-    x = 64'hC0300000001FFFBF;
-    y = 64'h398FFFFEFFFFF800;
-    z = 64'hBEF00001FFFBFFFF;
-    ans = 64'hBEF00001FFFBFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2521697\n");
-    end
-    x = 64'hC025AA627143737D;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h8010000000000000;
-    ans = 64'hBCE5AA627143737C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2522311\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h43C0000003F7FFFE;
-    z = 64'hC800000004000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2522925\n");
-    end
-    x = 64'hBFFFFFFFF7FFFFFE;
-    y = 64'h3FD0000000000001;
-    z = 64'hC7E55EFA4B05F9A4;
-    ans = 64'hC7E55EFA4B05F9A4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2523539\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h43F000080001FFFE;
-    z = 64'hC340000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2524153\n");
-    end
-    x = 64'hB80103FFFFFFFFFF;
-    y = 64'h3FDE95FBB84960D4;
-    z = 64'h401FFFFF8FFFFFFF;
-    ans = 64'h401FFFFF8FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2524767\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE8000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2525381\n");
-    end
-    x = 64'hC02DFBFFFFFFFFFF;
-    y = 64'hCAADFFFFFFFFFFDF;
-    z = 64'h3FE0000000000001;
-    ans = 64'h4AEC1C3FFFFFFFE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2525995\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h3FE0000000000000;
-    z = 64'h9A30ABB2E44153EF;
-    ans = 64'h7FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2526609\n");
-    end
-    x = 64'h3DC0CBF5120273C1;
-    y = 64'hBFDFFC0000000002;
-    z = 64'hBFDEFFFFFFFFFFFE;
-    ans = 64'hBFDF000000043275;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2527223\n");
-    end
-    x = 64'hCA7FEFF7FFFFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h8000000000000001;
-    ans = 64'hCA7FEFF7FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2527837\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hC03FFFF9FFFFFFFE;
-    z = 64'h3D5FFFFFFFFB7FFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2528451\n");
-    end
-    x = 64'h3FE002FFFFFFFFFF;
-    y = 64'h3FF0000000000000;
-    z = 64'hC050000000010003;
-    ans = 64'hC04FBFF400020006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2529065\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hC78FFFFE000003FF;
-    z = 64'hC010000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2529679\n");
-    end
-    x = 64'h402FF7FDFFFFFFFE;
-    y = 64'hCC7FEFFFFFFFF800;
-    z = 64'h41C001000000003F;
-    ans = 64'hCCBFE80200FFF800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2530293\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h4340000000000001;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2530907\n");
-    end
-    x = 64'h401AF433A5C310C2;
-    y = 64'hFFFF000000001000;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'hFFFF000000001000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2531521\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'hC02000000000040E;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2532135\n");
-    end
-    x = 64'hC1F000F000000000;
-    y = 64'hB80000800001FFFF;
-    z = 64'h3FC8304279FDE7F0;
-    ans = 64'h3FC8304279FDE7F0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2532749\n");
-    end
-    x = 64'h4000000080001000;
-    y = 64'h4000000000000001;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2533363\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h4095FFFFFFFFFFFF;
-    z = 64'h43DDFFFFFFF7FFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2533977\n");
-    end
-    x = 64'h47E00000000083FF;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hA81F7FFFFFFFFFFE;
-    ans = 64'h48000000000083FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2534591\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hBFAC9D7B95393F9A;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hFF9C9D7B95393F9A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2535205\n");
-    end
-    x = 64'h47FD53F8480209BD;
-    y = 64'h5B10000000003FE0;
-    z = 64'h3818000000000006;
-    ans = 64'h631D53F848027ED2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2535819\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h4010000000000001;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2536433\n");
-    end
-    x = 64'h402000040003FFFE;
-    y = 64'h3FFA36685A1C57E1;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h402A366EE7BCFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2537047\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h41DFFDFFFFFFFFFC;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2537661\n");
-    end
-    x = 64'h41E7FFFFFFFFFBFF;
-    y = 64'h4003FFFEFFFFFFFE;
-    z = 64'h44C0000003BFFFFF;
-    ans = 64'h44C0000003C000EF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2538275\n");
-    end
-    x = 64'hC00FFFFFFFDFFFF0;
-    y = 64'h4340000000000000;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2538889\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h3C60DB966C536079;
-    z = 64'hC05FFFFFE8000000;
-    ans = 64'h7C50DB966C536079;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2539503\n");
-    end
-    x = 64'hC5F00001007FFFFE;
-    y = 64'h4340000000000001;
-    z = 64'hBFF56B74EF72E498;
-    ans = 64'hC9400001007FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2540117\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h43D00000081FFFFF;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2540731\n");
-    end
-    x = 64'h48BFFFEFFFDFFFFF;
-    y = 64'hC0EFFFFFFFF9FFFF;
-    z = 64'hC3E7DFFFFFFFFFFF;
-    ans = 64'hC9BFFFEFFFDA0001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2541345\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h7FE0000000000000;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2541959\n");
-    end
-    x = 64'h3FE0002000000040;
-    y = 64'h3FEC0ABDA0188AA0;
-    z = 64'h3CA0000000000000;
-    ans = 64'h3FDC0AF5B593CB43;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2542573\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h7FE0000000000001;
-    z = 64'hC3EA2ECD4C6AACA2;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2543187\n");
-    end
-    x = 64'h402FFFFFFFFFBF80;
-    y = 64'h3FFFFFF00FFFFFFF;
-    z = 64'h403462A60FA855C0;
-    ans = 64'h404A314B0FD40AA0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2543801\n");
-    end
-    x = 64'h47E0000800001FFE;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2544415\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h41BFFDFFFFFFBFFF;
-    z = 64'h3FF0040000800000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2545029\n");
-    end
-    x = 64'h43F84175528AF1B9;
-    y = 64'h7FF0000000000000;
-    z = 64'h00134D6087A330D2;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2545643\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hB7EF4D5D25A022C2;
-    z = 64'hBFF0000000000000;
-    ans = 64'hF7DF4D5D25A022C2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2546257\n");
-    end
-    x = 64'hBB0FB893E0DECB72;
-    y = 64'hC1CFFFF7FFBFFFFF;
-    z = 64'hC03FFC0000003FFF;
-    ans = 64'hC03FFC0000003FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2546871\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h4000000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2547485\n");
-    end
-    x = 64'h476020000FFFFFFF;
-    y = 64'h37E01FFFFFBFFFFE;
-    z = 64'h0010000000000001;
-    ans = 64'h3F5040400FDF7FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2548099\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h8000000000000000;
-    z = 64'hD011287150AEFD43;
-    ans = 64'hD011287150AEFD43;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2548713\n");
-    end
-    x = 64'h4D64A98A03D930E9;
-    y = 64'hBFEFFFF000003FFF;
-    z = 64'hC03E000008000000;
-    ans = 64'hCD64A97FAF14584F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2549327\n");
-    end
-    x = 64'hB140008000000FFF;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2549941\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hC3500000040003FF;
-    z = 64'hA54FFFFFFFFF801F;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2550555\n");
-    end
-    x = 64'h403FFFFEFFFFFDFF;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'hC3EFFFFFF7FFEFFF;
-    ans = 64'hC3EFFFFFF7FFEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2551169\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hC1D0020000000003;
-    z = 64'hBFE0000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2551783\n");
-    end
-    x = 64'h207FFFFFFFFFFF07;
-    y = 64'hBFE000000000401F;
-    z = 64'hB7E0040FFFFFFFFF;
-    ans = 64'hB7E0040FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2552397\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h3FF0000000000001;
-    ans = 64'hC007FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2553011\n");
-    end
-    x = 64'hBFB7539AB7055255;
-    y = 64'hB7F07FFFFFFC0000;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h37B80E378CB7A801;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2553625\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h41CFFFE0007FFFFF;
-    ans = 64'h41CFFFDFFE7FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2554239\n");
-    end
-    x = 64'hB0BFFFFFF8000000;
-    y = 64'hC039090F6427704A;
-    z = 64'h37FCC8AD640425EC;
-    ans = 64'h37FCC8AD640425EC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2554853\n");
-    end
-    x = 64'hC1FA7A8D6AE07DA3;
-    y = 64'hBCA0000000000001;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h402000001A7A8D6A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2555467\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hBFAFFFFFFFF80001;
-    z = 64'hA370000000008006;
-    ans = 64'hFF9FFFFFFFF80001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2556081\n");
-    end
-    x = 64'hBF141E8D0C4FEF1D;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h43FFFE00000001FF;
-    ans = 64'h43FFFE00000001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2556695\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h4E401FFFFFFFFBFE;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2557309\n");
-    end
-    x = 64'h3FE2E1C5E52BB3A1;
-    y = 64'hC3F0004100000000;
-    z = 64'h402FFFFE0003FFFF;
-    ans = 64'hC3E2E2129A5FA6A3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2557923\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hBFD0000000000001;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'hFFC0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2558537\n");
-    end
-    x = 64'h3895AD9CB6F014AE;
-    y = 64'h48E00000003FF7FF;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2559151\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h43DBFDFA22D31748;
-    ans = 64'hFFCFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2559765\n");
-    end
-    x = 64'hCB5FFF000FFFFFFE;
-    y = 64'hBEBBFE0000000000;
-    z = 64'hFFD397BE63CB741C;
-    ans = 64'hFFD397BE63CB741C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2560379\n");
-    end
-    x = 64'hB810002002000000;
-    y = 64'hBFE0000000000000;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2560993\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h40000000000017FF;
-    z = 64'h3FE8000000000080;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2561607\n");
-    end
-    x = 64'h407FFFFF00003FFF;
-    y = 64'hBFE0000000000001;
-    z = 64'h247FFFEFFFFFFFFB;
-    ans = 64'hC06FFFFF00004001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2562221\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h434FFFFFFFF8007F;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2562835\n");
-    end
-    x = 64'h3CAFFFDFFFFFFFF8;
-    y = 64'h4036FF793EA8AA59;
-    z = 64'hC3F615879A14A987;
-    ans = 64'hC3F615879A14A987;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2563449\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hBFF0000000000000;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2564063\n");
-    end
-    x = 64'hA6F004000000001F;
-    y = 64'h3800000000000FF7;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2564677\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hBFF0000000000001;
-    z = 64'hBFCFFFFFFFFFFC07;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2565291\n");
-    end
-    x = 64'hC04000001FF7FFFF;
-    y = 64'hFD2FFFBFFFF7FFFF;
-    z = 64'h40100000000007EF;
-    ans = 64'h7D7FFFC03FE7801D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2565905\n");
-    end
-    x = 64'h3E5EFFFFFFDFFFFF;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h4000000000000000;
-    ans = 64'h3FFFFFFFF0800000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2566519\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hBFE000040000000E;
-    z = 64'hA21FFE00000FFFFF;
-    ans = 64'hFFD000040000000E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2567133\n");
-    end
-    x = 64'h3F00200000000000;
-    y = 64'hC000000000000000;
-    z = 64'h3F7FFFEFFFF80000;
-    ans = 64'h3F7FBF6FFFF80000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2567747\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h7FE3F4CB8A40190A;
-    z = 64'hBCA0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2568361\n");
-    end
-    x = 64'h3CA007EFFFFFFFFE;
-    y = 64'h79400001FFFDFFFF;
-    z = 64'h3F300000008007FE;
-    ans = 64'h75F007F200FBFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2568975\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h3FD0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2569589\n");
-    end
-    x = 64'h3FEFFFFFFDBFFFFF;
-    y = 64'h3FE0808805F24554;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2570203\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hC010000000000000;
-    z = 64'hC1F00FFFFDFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2570817\n");
-    end
-    x = 64'h3FFFFFFF7FFFE000;
-    y = 64'hC8003FFFFFFFFFFB;
-    z = 64'hEB6FFFFFFFFFF3FF;
-    ans = 64'hEB6FFFFFFFFFF3FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2571431\n");
-    end
-    x = 64'h45200001FF7FFFFF;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h3FF0000000000001;
-    ans = 64'hC5500001FF7FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2572045\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h7FEFFFFFEEFFFFFF;
-    z = 64'hBF3FFFFFDFFFFDFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2572659\n");
-    end
-    x = 64'h000FFFDFFFFFFF00;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hC3FA99119A2842A6;
-    ans = 64'hC3FA99119A2842A6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2573273\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h3FC0000000080003;
-    z = 64'h8010000000000001;
-    ans = 64'h7FB0000000080003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2573887\n");
-    end
-    x = 64'hBF70017FFFFFFFFF;
-    y = 64'h4C9F9B8BEED274A1;
-    z = 64'h381FF80007FFFFFF;
-    ans = 64'hCC1F9E8283F0D85A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2574501\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h3CA0000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2575115\n");
-    end
-    x = 64'hFFDFFF7FFF7FFFFF;
-    y = 64'h40FFFFFFFFFFFFBE;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2575729\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hCE2FFFFF00001FFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2576343\n");
-    end
-    x = 64'h38010000FFFFFFFF;
-    y = 64'h2B2FBFFFFFFC0000;
-    z = 64'hC3F000000000FE00;
-    ans = 64'hC3F000000000FE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2576957\n");
-    end
-    x = 64'hB84FFFE040000000;
-    y = 64'hFFE0000000000001;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h783FFFE040000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2577571\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'h4343A027130C87B4;
-    z = 64'h80000000000001DF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2578185\n");
-    end
-    x = 64'h47FFFFFFDFFFFFE0;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h00004003FFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2578799\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hBFDCD7EBDC5A0408;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'hFFCCD7EBDC5A0408;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2579413\n");
-    end
-    x = 64'hFFEFFFFFFFFE0400;
-    y = 64'hBF2000FBFFFFFFFF;
-    z = 64'h3E8401FFFFFFFFFF;
-    ans = 64'h7F2000FBFFFF01EF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2580027\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hFFF0000000000001;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2580641\n");
-    end
-    x = 64'hC08FFFFFFFFF7FDE;
-    y = 64'h43D09DCF5E6E7F53;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC4709DCF5E6E3CCA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2581255\n");
-    end
-    x = 64'h7FE0000000000000;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hC00FFFFFFFC0003F;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2581869\n");
-    end
-    x = 64'h3EE03F0000000000;
-    y = 64'hB818459D897A9352;
-    z = 64'h3FF0001FF7FFFFFF;
-    ans = 64'h3FF0001FF7FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2582483\n");
-    end
-    x = 64'hC03FFFFFFFFFF810;
-    y = 64'h0000000000000000;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2583097\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h43CEC1D751CCA01A;
-    z = 64'h449A27D1BF4384DC;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2583711\n");
-    end
-    x = 64'h48000FFFFFFFFDFF;
-    y = 64'h0000000000000001;
-    z = 64'h22DFFFFFF83FFFFF;
-    ans = 64'h22DFFFFFF83FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2584325\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hB7FC2CB5D458BDC2;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2584939\n");
-    end
-    x = 64'hFFEFFFFFFFFF7F7E;
-    y = 64'hC0F5EDD88E0E7D5D;
-    z = 64'hBEDDD10872C31AB9;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2585553\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h0010000000000000;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2586167\n");
-    end
-    x = 64'h301AF9D2D5A4BA0D;
-    y = 64'hC7FFDFFFFFFFFFFC;
-    z = 64'hC010000000000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2586781\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h0010000000000001;
-    z = 64'hFFD000000003FC00;
-    ans = 64'hFFD000000003FC00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2587395\n");
-    end
-    x = 64'h401903F79E80A3D6;
-    y = 64'h4003A3DBDB0C18E4;
-    z = 64'hC34002001FFFFFFE;
-    ans = 64'hC34002001FFFFFF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2588009\n");
-    end
-    x = 64'h434FFFFFEFFFEFFE;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2588623\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hC1C7559F1A1AD753;
-    z = 64'hBBE000000FFFFF00;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2589237\n");
-    end
-    x = 64'h7FE0FFFFFFFF7FFF;
-    y = 64'h3CA0000000000000;
-    z = 64'h43CF7D67F6C113D7;
-    ans = 64'h7C90FFFFFFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2589851\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h3EFFFFFF80100000;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2590465\n");
-    end
-    x = 64'h3DF88E3F2C57962B;
-    y = 64'h41EFFE00007FFFFF;
-    z = 64'hFFF00000200001FF;
-    ans = 64'hFFF80000200001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2591079\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h0000000000000000;
-    ans = 64'h7CA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2591693\n");
-    end
-    x = 64'h4A00000003FFE000;
-    y = 64'h43E5972BA17D5A64;
-    z = 64'hC000000000000001;
-    ans = 64'h4DF5972BA6E2FA1E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2592307\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h3FD0000000000000;
-    z = 64'hBFE28124FEC4E8F9;
-    ans = 64'h7FC0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2592921\n");
-    end
-    x = 64'h5C700006FFFFFFFF;
-    y = 64'hC3C88EB3A3479B67;
-    z = 64'h8010000000001FDE;
-    ans = 64'hE0488EBE61B632D5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2593535\n");
-    end
-    x = 64'hC3F4D646CE330C0B;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h3CA0000000000001;
-    ans = 64'hC3E4D646CE330C0A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2594149\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hC1FFFFFFFFFF0000;
-    z = 64'hCEC03FFFFFFF7FFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2594763\n");
-    end
-    x = 64'h47EFF07FFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h3A3FFFFFFFFF9FFE;
-    ans = 64'h47DFF07FFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2595377\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h3D7FC86542A6B145;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000001FC9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2595991\n");
-    end
-    x = 64'h9B4FDFFFFFFFFFFB;
-    y = 64'h41FFFFFFFEEFFFFF;
-    z = 64'h4FEFFF0000000080;
-    ans = 64'h4FEFFF0000000080;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2596605\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h3FE0000000000001;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2597219\n");
-    end
-    x = 64'h78BFFFFFBFFFFDFF;
-    y = 64'h002001FBFFFFFFFE;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2597833\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h3CA0001FFFFFFFBF;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h37F0000017FFFFFF;
+    ReadData3E = 64'h7FE0000000000000;
     ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2598447\n");
+    	$fwrite(fp,"1038869\n");
     end
-    x = 64'h3800000007FFFFFE;
-    y = 64'hB7FFFFFFF80003FF;
-    z = 64'h43D58662EFB06D82;
-    ans = 64'h43D58662EFB06D82;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FB1FFFFFFFFEFFE;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'h40CF7FFFC0000000;
+    ans = 64'h40CF7FB7C0000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2599061\n");
+    	$fwrite(fp,"1039175\n");
     end
-    x = 64'hC0FEFFFFDFFFFFFF;
-    y = 64'h3FF0000000000001;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'hC0FEFFFFE0000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFDE8D5A73D26464;
+    ReadData3E = 64'h37F9F76C367CE95E;
+    ans = 64'hFFCE8D5A73D26463;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2599675\n");
+    	$fwrite(fp,"1039481\n");
     end
-    x = 64'h7FE0000000000001;
-    y = 64'hE54FE00FFFFFFFFF;
-    z = 64'hC1E721896DA410CA;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3E0FA37875781127;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'hC15FA37875781127;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2600289\n");
+    	$fwrite(fp,"1039787\n");
     end
-    x = 64'h800000000E000000;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h034FFFF80FFFFFFE;
-    ans = 64'h034FFFF80FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hB81F7FFFFFFFDFFF;
+    ReadData2E = 64'hC800000100000000;
+    ReadData3E = 64'h6CB1FFFFFFBFFFFE;
+    ans = 64'h6CB1FFFFFFBFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2600903\n");
+    	$fwrite(fp,"1040093\n");
     end
-    x = 64'h7FE0000000000001;
-    y = 64'hC03F800007FFFFFF;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2601517\n");
-    end
-    x = 64'hC3DFFFFFFFEFEFFF;
-    y = 64'h380CD67FF96631CD;
-    z = 64'hBFF001FFFFFFDFFF;
-    ans = 64'hBFF001FFFFFFDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2602131\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h4000000000000000;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'h7CB8000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2602745\n");
-    end
-    x = 64'hBFCFF80000FFFFFE;
-    y = 64'h434FFFFD7FFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hC32FF7FD819FFFEB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2603359\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h59303FFFF7FFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2603973\n");
-    end
-    x = 64'hC37FFFFEFFFFFFFF;
-    y = 64'h40C00000000BFFFE;
-    z = 64'h47FFFFFF7FFFFFF7;
-    ans = 64'h47FFFFFF7FFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2604587\n");
-    end
-    x = 64'h19AC61120CE93DEC;
-    y = 64'h4010000000000000;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h19CC61120CE93DEC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2605201\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hBFC20000000001FE;
-    z = 64'h41DFFFC00007FFFF;
-    ans = 64'hFFB20000000001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2605815\n");
-    end
-    x = 64'hBFE000007FFFFF00;
-    y = 64'h4010000000000001;
-    z = 64'h7FD0000000002000;
-    ans = 64'h7FD0000000002000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2606429\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h7FF00003FFFFFFFD;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h7FF80003FFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2607043\n");
-    end
-    x = 64'h41EFFFFFEFFFFFC0;
-    y = 64'hBF0FFFF00003FFFE;
-    z = 64'h3C94001FFFFFFFFE;
-    ans = 64'hC10FFFEFF00407BE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2607657\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2608271\n");
-    end
-    x = 64'hC010040000FFFFFF;
-    y = 64'hC0D1FFFFFFFFC000;
-    z = 64'hBFE0000000000000;
-    ans = 64'h40F20478011FBFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2608885\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h4340000000000001;
-    z = 64'h400F00001FFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2609499\n");
-    end
-    x = 64'h3CAFFFFFF7FF0000;
-    y = 64'hC0A069D658AB80BD;
-    z = 64'h400FC0000000003F;
-    ans = 64'h400FBFFFFFFFFC25;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2610113\n");
-    end
-    x = 64'h38000FFEFFFFFFFE;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h0000000000000000;
-    ans = 64'h3B600FFEFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2610727\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hBEAFFFF0000001FF;
-    z = 64'h3500000000000FF8;
-    ans = 64'hFE9FFFF000000201;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2611341\n");
-    end
-    x = 64'hC06FFFF800000010;
-    y = 64'h7FE0000000000000;
-    z = 64'hC1DF1F5FFFC2803A;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2611955\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h400020001FFFFFFF;
-    z = 64'h4010000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2612569\n");
-    end
-    x = 64'hAE56D8F6C524E8AD;
-    y = 64'hC030000060000000;
-    z = 64'h4340000000000002;
-    ans = 64'h4340000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2613183\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hC340000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2613797\n");
-    end
-    x = 64'hC3E54C4A34BFA6E4;
-    y = 64'hBFC00000FFFFFBFF;
-    z = 64'hBFD0000000000001;
-    ans = 64'h43B54C4B898444DC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2614411\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h7FF0000000000000;
-    z = 64'h002FFF800001FFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2615025\n");
-    end
-    x = 64'hC0103FF800000000;
-    y = 64'h434007FFFFFFEFFF;
-    z = 64'hBC70000FFFFFFFF7;
-    ans = 64'hC3604817FBFFEFBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2615639\n");
-    end
-    x = 64'hBF2175E0432D769D;
-    y = 64'h7FF0000000000001;
-    z = 64'hFFF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2616253\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hB8040179B06430AA;
-    z = 64'h43E0000000800400;
-    ans = 64'hF7F40179B06430AB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2616867\n");
-    end
-    x = 64'h401EFFFFFFFFFFF7;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'hC00FFFFBFFFBFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2617481\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h80200004FFFFFFFF;
-    z = 64'h4000000000000001;
-    ans = 64'hC0000009FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2618095\n");
-    end
-    x = 64'h37EFFF7FF7FFFFFF;
-    y = 64'h3EB87964ABACA6C6;
-    z = 64'hC014000000080000;
-    ans = 64'hC014000000080000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2618709\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h8000000000000001;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2619323\n");
-    end
-    x = 64'h37FFFFDFFFFE0000;
-    y = 64'h47F23D7F24A38646;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'h40023D6CE7233DCA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2619937\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'hBED0003F7FFFFFFE;
-    ans = 64'hC00000020007EFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2620551\n");
-    end
-    x = 64'h215F7FFFBFFFFFFE;
-    y = 64'h3960000100000001;
-    z = 64'hC7EFFFFBFEFFFFFF;
-    ans = 64'hC7EFFFFBFEFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2621165\n");
-    end
-    x = 64'hC071FFFFFF7FFFFE;
-    y = 64'h8010000000000000;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2621779\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hC0200000FDFFFFFF;
-    z = 64'h4053FDFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2622393\n");
-    end
-    x = 64'hC7FFFFFFE0000010;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hBF2F800000000001;
-    ans = 64'hBF2F800000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2623007\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h801000000001FEFF;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'hBDCFF00800000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2623621\n");
-    end
-    x = 64'h3800FFFFFFFFF800;
-    y = 64'h000FBC0000000000;
-    z = 64'h40DFEFFFFFFFFFF0;
-    ans = 64'h40DFEFFFFFFFFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2624235\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hBCA0000000000000;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hFC90000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2624849\n");
-    end
-    x = 64'h31BFFFFFE003FFFF;
-    y = 64'h41EAFA4764C7E465;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h33BAFA4749D0FC48;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2625463\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h7FEFFFFFDFFFFFFC;
-    ans = 64'h7FEFFFFFDFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2626077\n");
-    end
-    x = 64'hFFFFFFFDFFFFFFF7;
-    y = 64'hC02FF00FFFFFFFFF;
-    z = 64'h3FBFFFFFBFFDFFFF;
-    ans = 64'hFFFFFFFDFFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2626691\n");
-    end
-    x = 64'hBFAFF7FFFFFE0000;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2627305\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hC02001FFFFFFFFFE;
-    z = 64'h3810000000000DFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2627919\n");
-    end
-    x = 64'h001AE1C1BB5B4FDA;
-    y = 64'hBFD0000000000001;
-    z = 64'hC17FFFFFFFFFFFCF;
-    ans = 64'hC17FFFFFFFFFFFCF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2628533\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hC24E00000000001F;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2629147\n");
-    end
-    x = 64'h30E1539D6F604313;
-    y = 64'h415427C6462AF0E6;
-    z = 64'h4038BBB7881BC9D8;
-    ans = 64'h4038BBB7881BC9D8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2629761\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hFFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2630375\n");
-    end
-    x = 64'h37EFFFFFFFFDFF7E;
-    y = 64'hBFAFFFFFFFFFD000;
-    z = 64'h8010000000000000;
-    ans = 64'hB7AFFFFFFFFDCF7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2630989\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hBFE0000000000001;
-    z = 64'h40332E5BBB9E9819;
-    ans = 64'hFFD0000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2631603\n");
-    end
-    x = 64'h396E5358D2C85AD4;
-    y = 64'hBFDFEFFFFFFFFFFF;
-    z = 64'hBFDFC03FFFFFFFFE;
-    ans = 64'hBFDFC03FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2632217\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hC340000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2632831\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hF4500000007FFF7E;
-    z = 64'h380FFFF800100000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2633445\n");
-    end
-    x = 64'h40340001FFFFFFFE;
-    y = 64'hBFF0000000000000;
-    z = 64'hC1D0080000001FFF;
-    ans = 64'hC1D008000500207F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2634059\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hFFE19967615D1CE2;
-    z = 64'h3FE0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2634673\n");
-    end
-    x = 64'hC000000002000100;
-    y = 64'hB7F0002000000000;
-    z = 64'h402002000000000F;
-    ans = 64'h402002000000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2635287\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hBFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2635901\n");
-    end
-    x = 64'hD240007FFFFEFFFF;
-    y = 64'hBFCFFFEFFFF80000;
-    z = 64'h8000000000000001;
-    ans = 64'h52200077FFBAFFE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2636515\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hC000000000000000;
-    z = 64'h08D127F5978046FD;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2637129\n");
-    end
-    x = 64'hBCE00005FFFFFFFF;
-    y = 64'h462000003FFFFFFE;
-    z = 64'hEFF00020001FFFFF;
-    ans = 64'hEFF00020001FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2637743\n");
-    end
-    x = 64'h40236D3BE6BA89EE;
-    y = 64'hC000000000000001;
-    z = 64'hC010000000000001;
-    ans = 64'hC0376D3BE6BA89EF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2638357\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h37FFFF7FF7FFFFFE;
-    z = 64'h41F0B0E6E43095BE;
-    ans = 64'h77EFFF7FF8000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2638971\n");
-    end
-    x = 64'h41F000000FFF7FFF;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h3FE000100000003E;
-    ans = 64'hC21000000FFD7FFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2639585\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hC1F91E2D92C9A9B5;
-    z = 64'h3FD0000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2640199\n");
-    end
-    x = 64'hC5D0000000880000;
-    y = 64'h428FFFFFFBFFFDFE;
-    z = 64'h3F60FFFFFFFFFDFF;
-    ans = 64'hC86FFFFFFD0FFDFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2640813\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hC010000000000001;
-    z = 64'hBFE0000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2641427\n");
-    end
-    x = 64'hBFDFA132CC5B63C1;
-    y = 64'h402039FAE3724F00;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2642041\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hA84EFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2642655\n");
-    end
-    x = 64'hBFBFFFDFDFFFFFFE;
-    y = 64'h8010047FFFFFFFFF;
-    z = 64'h7FFFFFFFFFFBFFF0;
-    ans = 64'h7FFFFFFFFFFBFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2643269\n");
-    end
-    x = 64'hC800000020000000;
-    y = 64'hC340000000000000;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'h4B50000020000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2643883\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hC01FFFEFFFFFFF7E;
-    z = 64'h400FFFF800000080;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2644497\n");
-    end
-    x = 64'hFFEFFFDFFFFFFFC0;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hB7FFFF0000200000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2645111\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hC06003BFFFFFFFFF;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2645725\n");
-    end
-    x = 64'h37EB6092B4D1A495;
-    y = 64'h43600FFFFFFFFF7F;
-    z = 64'h4024003FFFFFFFFE;
-    ans = 64'h4024003FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2646339\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hFFE0000000000000;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2646953\n");
-    end
-    x = 64'h555E597CBADF25DC;
-    y = 64'hBFB0000002FFFFFE;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2647567\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h000DC2A2A032E095;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2648181\n");
-    end
-    x = 64'h0BB273916840FDDD;
-    y = 64'hBFD07FFFFFFFFF7E;
-    z = 64'h37E0020000800000;
-    ans = 64'h37E0020000800000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2648795\n");
-    end
-    x = 64'h801179AC2F89FF18;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'h4002F3585F13FE2F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2649409\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h3FFFFFDFFFFFDFFE;
-    z = 64'h401F80000000001F;
-    ans = 64'h7FEFFFDFFFFFE000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2650023\n");
-    end
-    x = 64'h3CAAF64D41610A74;
-    y = 64'hFFF0000000000001;
-    z = 64'hBF900000007FEFFF;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2650637\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'h401512D5D6AFD92E;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2651251\n");
-    end
-    x = 64'hC024007FFFFFFFFF;
-    y = 64'h3E4001000000003E;
-    z = 64'hC1DFFFFF00010000;
-    ans = 64'hC1DFFFFF00010000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2651865\n");
-    end
-    x = 64'h7FE0000000000001;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2652479\n");
-    end
-    x = 64'h3810001000000002;
-    y = 64'hFFDFFFF0000001FF;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2653093\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h0000000000000001;
-    z = 64'h37FFFFFF7FFFFEFF;
-    ans = 64'h3CCFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2653707\n");
-    end
-    x = 64'h3CA0000000400040;
-    y = 64'h000BFFFFFFFBFFFE;
-    z = 64'h4260000002000000;
-    ans = 64'h4260000002000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2654321\n");
-    end
-    x = 64'hC1EA26D0FBE678F4;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2654935\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hC3EFF69E32A24625;
-    z = 64'hBF88000800000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2655549\n");
-    end
-    x = 64'hC800000003F7FFFF;
-    y = 64'h0010000000000000;
-    z = 64'h47F92CC74CE08C7C;
-    ans = 64'h47F92CC74CE08C7C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2656163\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h3C0C7E4BEEEA4147;
-    z = 64'h0010000000000000;
-    ans = 64'h7C0C7E4BEEEA4146;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2656777\n");
-    end
-    x = 64'h45A0000800000020;
-    y = 64'h3F9D5B14C2083A69;
-    z = 64'h439EFDFFFFFFFFFE;
-    ans = 64'h454D5B2373725BA8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2657391\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hBCA0000000000000;
-    ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2658005\n");
-    end
-    x = 64'h000DFF0000000000;
-    y = 64'hC0800002FFFFFFFF;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2658619\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h3CA0000000000000;
-    z = 64'hE1BFFFFFFC1FFFFF;
-    ans = 64'h7C9FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2659233\n");
-    end
-    x = 64'hC8C608DD8889617B;
-    y = 64'h3FDFFFFFFFEFFFE0;
-    z = 64'h3FD0000000000000;
-    ans = 64'hC8B608DD887E5CF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2659847\n");
-    end
-    x = 64'h3FEFFFFFFFFBFFFD;
-    y = 64'h3CA0000000000001;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2660461\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hC1F33BC4DC616C1F;
-    z = 64'hC010000000001040;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2661075\n");
-    end
-    x = 64'h89D00800000007FF;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h41CF3D7795756252;
-    ans = 64'h41CF3D7795756252;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2661689\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h41CFDFDFFFFFFFFE;
-    z = 64'h0000000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2662303\n");
-    end
-    x = 64'h46640000000001FE;
-    y = 64'h7FDDFFFFFFFFF7FF;
-    z = 64'hC1E000001FFFFF80;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2662917\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h3FD0000000000001;
-    z = 64'h8010000000000001;
-    ans = 64'h7FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2663531\n");
-    end
-    x = 64'h402D74C2FBFA1FDB;
-    y = 64'h47F000000020FFFE;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h482D74C2FC36E0A9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2664145\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h41F0007FFFC00000;
-    ans = 64'h7FDFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2664759\n");
-    end
-    x = 64'h13601FDFFFFFFFFE;
-    y = 64'hC1D00000000201FF;
-    z = 64'h43DEC9C680E70DAB;
-    ans = 64'h43DEC9C680E70DAB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2665373\n");
-    end
-    x = 64'hC34F87FB54D961A0;
-    y = 64'h3FE0000000000000;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hC33F87FB54D961A0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2665987\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hC13FBFFFFFFFFFFC;
-    z = 64'h9E0007FEFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2666601\n");
-    end
-    x = 64'h608000000080FFFE;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'hBE5FFFFFFEFFFFF7;
-    ans = 64'h608000000080FFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2667215\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hB81FFFFDFFFFFFFE;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2667829\n");
-    end
-    x = 64'hC1FFFFFFFFFE4000;
-    y = 64'hBFEFFF0007FFFFFE;
-    z = 64'h402FFFFFFFFFFF7F;
-    ans = 64'h41FFFF0008FE400C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2668443\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h3FF0000000000000;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2669057\n");
-    end
-    x = 64'h405DFFFFFFFFBFFF;
-    y = 64'hBFC37916008602E8;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'hC02C830940FAF78E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2669671\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h47EFFFFFFFFEFFBF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2670285\n");
-    end
-    x = 64'h800FFDFFFFFFEFFE;
-    y = 64'h3FF81FFFFFFFFFFF;
-    z = 64'h1261EBCAEBB0E94A;
-    ans = 64'h1261EBCAEBB0E94A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2670899\n");
-    end
-    x = 64'hD0300004001FFFFF;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hD0400004001FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2671513\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hC7E0000001FFBFFF;
-    z = 64'h9E2FFFFFFFFFF87F;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2672127\n");
-    end
-    x = 64'hC3DFFFFFFFFBFFFB;
-    y = 64'h4000000000000001;
-    z = 64'hB81FA9628B39210C;
-    ans = 64'hC3EFFFFFFFFBFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2672741\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h7FDA01B736DBF682;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2673355\n");
-    end
-    x = 64'h403EFFFFFFFF8000;
-    y = 64'h40D000008FFFFFFF;
-    z = 64'h3E205EB8191C94FC;
-    ans = 64'h411F000116FF801F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2673969\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2674583\n");
-    end
-    x = 64'h8D100009FFFFFFFE;
-    y = 64'hBF791618C4CC930D;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2675197\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h4010000000000001;
-    z = 64'hC3EFFFDFE0000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2675811\n");
-    end
-    x = 64'h2E6FFFFFE2000000;
-    y = 64'h47E00FFFFFFFFFF8;
-    z = 64'hBFEF00000003FFFE;
-    ans = 64'hBFEF00000003FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2676425\n");
-    end
-    x = 64'h6C9FE000007FFFFE;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hBCA0000000000000;
-    ans = 64'h6CCFE000007FFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2677039\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h40E00000000003F0;
-    z = 64'hC1C401FFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2677653\n");
-    end
-    x = 64'hC34FFFF8FFFFFFFF;
-    y = 64'h4340000000000000;
-    z = 64'h381FFFFFFEFFFFFA;
-    ans = 64'hC69FFFF8FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2678267\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hDC0F7FFFDFFFFFFF;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2678881\n");
-    end
-    x = 64'h5BA89D8E76702695;
-    y = 64'h403FFBFFFFFFDFFF;
-    z = 64'h402007FFFFFFFFFC;
-    ans = 64'h5BF89A7AC4A13FF2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2679495\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2680109\n");
-    end
-    x = 64'hC02FFFFDFFFFBFFF;
-    y = 64'hBFAFFFFDFFFF8000;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FFFFFFDFFFFB001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2680723\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h7FE0000000000000;
-    z = 64'h402FE00001FFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2681337\n");
-    end
-    x = 64'hFFF0007FFFFFFFF0;
-    y = 64'hC1CFFFDFFEFFFFFF;
-    z = 64'hBFF0000400000000;
-    ans = 64'hFFF8007FFFFFFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2681951\n");
-    end
-    x = 64'h380FFFFFEFDFFFFE;
-    y = 64'h7FE0000000000001;
-    z = 64'h8010000000000001;
-    ans = 64'h77FFFFFFEFE00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2682565\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h4C40007FFFFFFBFF;
-    z = 64'hFFE00010FFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2683179\n");
-    end
-    x = 64'hFFE60948A045D052;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h416830715668BF7E;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2683793\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hB7EFFFFFFFFFFFFF;
-    z = 64'hC340000000000001;
-    ans = 64'hF7EFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2684407\n");
-    end
-    x = 64'h43EBE98FE3471EF1;
-    y = 64'hC3DFFC00000001FF;
-    z = 64'hFFDFFFFF7FFFFFFF;
-    ans = 64'hFFDFFFFF7FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2685021\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h7FF0000000000001;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2685635\n");
-    end
-    x = 64'h367FEFFFFFDFFFFF;
-    y = 64'h3C28000000008000;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2686249\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h3FC0008FFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2686863\n");
-    end
-    x = 64'h3FBFFFE000000007;
-    y = 64'h787FFFE0003FFFFE;
-    z = 64'h43CFFE0000001FFE;
-    ans = 64'h784FFFC0005FFFC5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2687477\n");
-    end
-    x = 64'h3CA000400000007F;
-    y = 64'h8000000000000000;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h800FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2688091\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h3FE00000007FFEFF;
-    z = 64'h403FFFFE00008000;
-    ans = 64'h7FE00000007FFEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2688705\n");
-    end
-    x = 64'hAB80000008000020;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hC3CFFFFFFFFFC010;
-    ans = 64'hC3CFFFFFFFFFC010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2689319\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hB801FFFDFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hF801FFFDFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2689933\n");
-    end
-    x = 64'hC00FFFC003FFFFFF;
-    y = 64'hFFE003FFFEFFFFFF;
-    z = 64'h3FEE3B6F7416A277;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2690547\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h8010000000000000;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2691161\n");
-    end
-    x = 64'hE100000080000006;
-    y = 64'hC04FFFFFFFFE000F;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h616000007FFF000D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2691775\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h8010000000000001;
-    z = 64'h381FFFF802000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2692389\n");
-    end
-    x = 64'h40B0048000000000;
-    y = 64'h3FE3ED76B6489C1D;
-    z = 64'h3E7FBFFFFFFFFFBF;
-    ans = 64'h40A3F3117FAFD889;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2693003\n");
-    end
-    x = 64'h41DFFFFFFF7FF000;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2693617\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h41C000000000013E;
-    z = 64'hFFF004000003FFFE;
-    ans = 64'hFFF804000003FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2694231\n");
-    end
-    x = 64'hF7D00001F7FFFFFF;
-    y = 64'hBCA0000000000001;
-    z = 64'h7FD0000000017FFF;
-    ans = 64'h7FD0000000017FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2694845\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hBA6FFFFFFFFFFFEB;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hFA6FFFFFFFFFFFEA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2695459\n");
-    end
-    x = 64'h43F04EE0AE1C051B;
-    y = 64'hC0700FDFFFFFFFFE;
-    z = 64'hB7F1FFFFFEFFFFFF;
-    ans = 64'hC4705F0EF108C4E6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2696073\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'hFCAFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2696687\n");
-    end
-    x = 64'h3FA00400000007FF;
-    y = 64'h0014DB112901A6D9;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2697301\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hBFD0000000000000;
-    z = 64'h41F03FFFFFE00000;
-    ans = 64'hFFCFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2697915\n");
-    end
-    x = 64'hB812000000080000;
-    y = 64'hC24FFFFFFF00003F;
-    z = 64'hB98FE003FFFFFFFF;
-    ans = 64'h3A71FFC03F700023;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2698529\n");
-    end
-    x = 64'hBCDFFFFFFE1FFFFF;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2699143\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hC03FFFFDFFFDFFFE;
-    z = 64'h3FFFBFFFFFF7FFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2699757\n");
-    end
-    x = 64'h3FB000000100007F;
-    y = 64'hBFE0000000000000;
-    z = 64'hC00008001FFFFFFF;
-    ans = 64'hC000480020040001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2700371\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hD0126E987899EAFF;
-    z = 64'hC000000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2700985\n");
-    end
-    x = 64'hBC8117A78D57DE17;
-    y = 64'hBFE0000001FFFBFF;
-    z = 64'hC3FA1CA7FD3C5593;
-    ans = 64'hC3FA1CA7FD3C5593;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2701599\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h4010000000000000;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2702213\n");
-    end
-    x = 64'h434DFFFFFFFFFFDE;
-    y = 64'h71E86FF6019437FA;
-    z = 64'h3CA0000000000001;
-    ans = 64'h7546E8F6A17AF460;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2702827\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h3C63CCE2F498B2CB;
-    ans = 64'hFFEFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2703441\n");
-    end
-    x = 64'hC74B7FFFFFFFFFFE;
-    y = 64'hBFF000001000003F;
-    z = 64'hC0E0000002000007;
-    ans = 64'h474B80001B80006A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2704055\n");
-    end
-    x = 64'h83BFFC7FFFFFFFFF;
-    y = 64'hBFF0000000000001;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2704669\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h3FD8E249A50C7C32;
-    z = 64'h38101FFFFFFFFFC0;
-    ans = 64'h7FD8E249A50C7C31;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2705283\n");
-    end
-    x = 64'hC1E0000400000100;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h408FF77FFFFFFFFF;
-    ans = 64'h41F000043FEF00FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2705897\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h04B0DDD888155295;
-    z = 64'hBFF0000000000001;
-    ans = 64'h44B0DDD888155294;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2706511\n");
-    end
-    x = 64'hC034B755456A5C7C;
-    y = 64'h41E0000000000000;
-    z = 64'hBF1FFFFFFF7FFC00;
-    ans = 64'hC224B755456A5C8C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2707125\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hC000000000000001;
-    z = 64'h4000000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2707739\n");
-    end
-    x = 64'h3F4FFFEFFDFFFFFF;
-    y = 64'hC1F40DF17AEAA200;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'hC1540DE772B10572;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2708353\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h66700003FFDFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2708967\n");
-    end
-    x = 64'hBFEFFFFFFFFFC000;
-    y = 64'h002080000000000F;
-    z = 64'h0B9FFFFC0000007F;
-    ans = 64'h0B9FFFFC0000007F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2709581\n");
-    end
-    x = 64'h40500000007FFDFF;
-    y = 64'hC010000000000000;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2710195\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hC7E1FFFFFFFFFFFC;
-    z = 64'hC7D6500338CDEEFD;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2710809\n");
-    end
-    x = 64'hBEDFFF800000003E;
-    y = 64'hC010000000000001;
-    z = 64'h3FF0000400000007;
-    ans = 64'h3FF00023FF800007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2711423\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h3FE0001000000007;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'h7FE0001000000006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2712037\n");
-    end
-    x = 64'hBFC000000020000F;
-    y = 64'hC3488494D9B089E2;
-    z = 64'h400953DDF7890BE9;
-    ans = 64'h43188494D9E1932F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2712651\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hC340000000000000;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2713265\n");
-    end
-    x = 64'h37E0080000020000;
-    y = 64'h3FC9D48FACB73124;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h37B9E179F490C74F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2713879\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hC340000000000001;
-    z = 64'h3FBFDFFFFFFEFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2714493\n");
-    end
-    x = 64'h45C000003FFFFFFF;
-    y = 64'hC56FFFFF8003FFFF;
-    z = 64'h4DF00000080007FF;
-    ans = 64'h4DF00000080005FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2715107\n");
-    end
-    x = 64'h403FFFC000000FFE;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'hC39FFFC000000FFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2715721\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'h41CFFDFFFFFFFC00;
-    z = 64'hC1DFF80100000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2716335\n");
-    end
-    x = 64'h92FCBDCB2FA72585;
-    y = 64'hFFE0000000000000;
-    z = 64'h3DFFC0000001FFFF;
-    ans = 64'h52ECBDCB2FA72585;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2716949\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hC3C00400000007FE;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2717563\n");
-    end
-    x = 64'hBCA0000000010010;
-    y = 64'hC3CFC00000000002;
-    z = 64'hB7E0003FFFFFFFDF;
-    ans = 64'h407FC0000001FC22;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2718177\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2718791\n");
-    end
-    x = 64'hC0EFFFDFFFFFFBFF;
-    y = 64'hBE3FFFFFFF7FFC00;
-    z = 64'h0000000000000000;
-    ans = 64'h3F3FFFDFFF7FF87F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2719405\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hFFF0000000000000;
-    z = 64'h801FFFFFFFFFFFF4;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2720019\n");
-    end
-    x = 64'hC3DFFDFFFFFFFC00;
-    y = 64'hC7EFFC0000000000;
-    z = 64'h3FD007FFFFFFFFBF;
-    ans = 64'h4BDFFA003FFFFC01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2720633\n");
-    end
-    x = 64'h7FDFFFFFFFF87FFF;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h4010000000000000;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2721247\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFF;
-    y = 64'hB7F0007FFFFDFFFF;
-    z = 64'h41D00009FFFFFFFF;
-    ans = 64'hF7F0007FFFFDFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2721861\n");
-    end
-    x = 64'h41F000007FFEFFFF;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h31620000000001FF;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2722475\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hBCAE75B7DA64DA8B;
-    z = 64'hBFD0000000000000;
-    ans = 64'hFCAE75B7DA64DA89;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2723089\n");
-    end
-    x = 64'h400000000004001F;
-    y = 64'hB23FFFFFC2000000;
-    z = 64'hC0303FFFFFDFFFFF;
-    ans = 64'hC0303FFFFFDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2723703\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h3FE0000000000000;
-    ans = 64'h4011FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2724317\n");
-    end
-    x = 64'h37FFFFFF7FFFFFDE;
-    y = 64'h3FE0004400000000;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2724931\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h801AD09F91401F94;
-    ans = 64'h400FFFFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2725545\n");
-    end
-    x = 64'h510FE00000000004;
-    y = 64'h3FC00000010007FF;
-    z = 64'h7FDFBF0000000000;
-    ans = 64'h7FDFBF0000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2726159\n");
-    end
-    x = 64'h480F30C3D189FBF8;
-    y = 64'h0010000000000001;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2726773\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h801FC40000000000;
-    z = 64'h405BFFFFEFFFFFFF;
-    ans = 64'h405A03BFEFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2727387\n");
-    end
-    x = 64'h8F6FFFFFFFFFFF3F;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h3E70403FFFFFFFFF;
-    ans = 64'h3E70403FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2728001\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hCA60000000003FBF;
-    z = 64'hBCA0000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2728615\n");
-    end
-    x = 64'hFFD000007FBFFFFF;
-    y = 64'h409529DF079AEA06;
-    z = 64'hC1F000002000000F;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2729229\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h3CA0000000000001;
-    z = 64'h3FD0000000000001;
-    ans = 64'h7CA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2729843\n");
-    end
-    x = 64'hC1BFFC0000FFFFFE;
-    y = 64'hC8000001FFC00000;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2730457\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hBFF0007FFFFF7FFF;
-    ans = 64'h7CAFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2731071\n");
-    end
-    x = 64'hC3431371803FAF5C;
-    y = 64'hC01E02B00FBA67F6;
-    z = 64'hBECE7C5499D55A61;
-    ans = 64'h4371E3D493A435F1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2731685\n");
-    end
-    x = 64'h47E07FFFFFFFFFBE;
-    y = 64'h3FD0000000000000;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h47C07FFFFFFFFFBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2732299\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hED7FFFFFFFFFE007;
-    z = 64'hDDCE000000800000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2732913\n");
-    end
-    x = 64'hAE3FFFFFF7FFFF7F;
-    y = 64'h3FD0000000000001;
-    z = 64'h3EB0000200007FFF;
-    ans = 64'h3EB0000200007FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2733527\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h4018AD954FA2661C;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2734141\n");
-    end
-    x = 64'hC3F0000001FFFF7E;
-    y = 64'hBD80008000001FFF;
-    z = 64'hC3CFFFFFC1FFFFFE;
-    ans = 64'hC3CFFFFFC1FEFFF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2734755\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h3FE0000000000000;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h7FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2735369\n");
-    end
-    x = 64'hC005FFFFFFFFFFFF;
-    y = 64'h00131D0C934B03B5;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2735983\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h3FE0000000000001;
-    z = 64'hC01000003E000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2736597\n");
-    end
-    x = 64'h3410007FFFFFFFF0;
-    y = 64'h3FDFFFFE07FFFFFF;
-    z = 64'hB7E42BFC32088109;
-    ans = 64'hB7E42BFC32088109;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2737211\n");
-    end
-    x = 64'h40C9F9C3F5F48C89;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h40C9FA43F5F48C87;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2737825\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h56EE000003FFFFFF;
-    z = 64'h480EFFFFFFFF8000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2738439\n");
-    end
-    x = 64'h6152307E846B6B2F;
-    y = 64'h3FF0000000000000;
-    z = 64'h3FBBFFFFFFFFFF7E;
-    ans = 64'h6152307E846B6B2F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2739053\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h3FCFFFFFF7FFFFFE;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h7FCFFFFFF7FFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2739667\n");
-    end
-    x = 64'hC060FFFFFFFFFFFB;
-    y = 64'hC03BE00000000000;
-    z = 64'hBFC1625D444CD847;
-    ans = 64'h40AD9DBA768AEEC4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2740281\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2740895\n");
-    end
-    x = 64'h3FDFFFFFFC000FFE;
-    y = 64'h7FEC0FE52F009BCC;
-    z = 64'hC340000000000000;
-    ans = 64'h7FDC0FE52B7EAD2C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2741509\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h4000000000000000;
-    z = 64'h408FFEFFFFFFFFFB;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2742123\n");
-    end
-    x = 64'h4DFFFFFD00000000;
-    y = 64'hC212000000000000;
-    z = 64'h43D00003FEFFFFFF;
-    ans = 64'hD021FFFE50000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2742737\n");
-    end
-    x = 64'h3E3FFFFFFFFFDFBE;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000010000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2743351\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hC801A4C88B03EBDD;
-    z = 64'h402F800020000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2743965\n");
-    end
-    x = 64'hB26FFFFC00000003;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h84B00007FFFFFFF7;
-    ans = 64'hB28FFFFC00000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2744579\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hC00130F25C0FC4FE;
-    z = 64'h8000000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2745193\n");
-    end
-    x = 64'h404087982EBE099A;
-    y = 64'hBFBFFBFFFFFF0000;
-    z = 64'h403004000FFFFFFF;
-    ans = 64'h4027C53C82242930;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2745807\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h0010000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2746421\n");
-    end
-    x = 64'h403249857D09F98B;
-    y = 64'h402FFFE000000020;
-    z = 64'hC010000000000001;
-    ans = 64'h4072097333847C93;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2747035\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h001DB6DB217A3447;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2747649\n");
-    end
-    x = 64'hB1A0000000000000;
-    y = 64'h402001FFFFFEFFFE;
-    z = 64'h403FFFFFFC000002;
-    ans = 64'h403FFFFFFC000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2748263\n");
-    end
-    x = 64'h6DD07FFFFFFFFFF6;
-    y = 64'h4340000000000001;
-    z = 64'h3FD0000000000001;
-    ans = 64'h71207FFFFFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2748877\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hC00FFFFFEFFEFFFF;
-    z = 64'h3D900000803FFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2749491\n");
-    end
-    x = 64'h3F90000000800000;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hFFFFFFFFFFFFFE01;
-    ans = 64'hFFFFFFFFFFFFFE01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2750105\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hBFE0000000002007;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2750719\n");
-    end
-    x = 64'h37EFFBFFFFFFC000;
-    y = 64'h378FFBFFFFFFFF7F;
-    z = 64'h427766C3FF898D65;
-    ans = 64'h427766C3FF898D65;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2751333\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h7FE0000000000001;
-    z = 64'h0000000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2751947\n");
-    end
-    x = 64'h4440008000000000;
-    y = 64'h038ABB97FC6031CE;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2752561\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h801EDFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2753175\n");
-    end
-    x = 64'hBE40203FFFFFFFFF;
-    y = 64'h3FB0000280000000;
-    z = 64'hBAA4591950B7103C;
-    ans = 64'hBE0020428509FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2753789\n");
-    end
-    x = 64'h7FDFFFFFFFFE001F;
-    y = 64'h7FF0000000000000;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2754403\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h3C3FFFFFFFFF007E;
-    z = 64'h3F4FFFFE000000FE;
-    ans = 64'h7C3FFFFFFFFF007C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2755017\n");
-    end
-    x = 64'hC02FFFFFFFFC0007;
-    y = 64'h7FF0000000000001;
-    z = 64'hC3F0000037FFFFFE;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2755631\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hBFBFF80000002000;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEC00FFFFFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2756245\n");
-    end
-    x = 64'h3FEC0FFFFFFFFFFE;
-    y = 64'h37E0082000000000;
-    z = 64'hC0305FFFFFFFFFFF;
-    ans = 64'hC0305FFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2756859\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2757473\n");
-    end
-    x = 64'h800FF81FFFFFFFFF;
-    y = 64'hC02FFFEC00000000;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2758087\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h8000000000000001;
-    z = 64'h44B1D069FC89E1A4;
-    ans = 64'h44B1D069FC89E1A4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2758701\n");
-    end
-    x = 64'hFFF000000005FFFF;
-    y = 64'hC80FFFFFFFFBDFFF;
-    z = 64'h800FFFFFFEFFDFFF;
-    ans = 64'hFFF800000005FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2759315\n");
-    end
-    x = 64'h475426384B2F52FF;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h877426384B2F52FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2759929\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hC083FFFDFFFFFFFF;
-    z = 64'h41F00000000400FF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2760543\n");
-    end
-    x = 64'hBFB000000001EFFF;
-    y = 64'h8010000000000000;
-    z = 64'hC010000000000010;
-    ans = 64'hC010000000000010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2761157\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h3FD45C4A28015794;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h7FD45C4A28015793;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2761771\n");
-    end
-    x = 64'hC003A9DCAAEBFAEA;
-    y = 64'h7FD8000000000006;
-    z = 64'hC7F2253D67209A0F;
-    ans = 64'hFFED7ECB0061F866;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2762385\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2762999\n");
-    end
-    x = 64'hE8D00000800FFFFF;
-    y = 64'h3FE000400000000F;
-    z = 64'hBFF0000000000000;
-    ans = 64'hE8C000408012004E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2763613\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hBCA0000000000000;
-    z = 64'h000020000001FFFF;
-    ans = 64'hFC9FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2764227\n");
-    end
-    x = 64'h3E430E36893A9156;
-    y = 64'hB85FFFBFFFE00000;
-    z = 64'h47F000003FFDFFFE;
-    ans = 64'h47F000003FFDFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2764841\n");
-    end
-    x = 64'h41CFFFFFFFFFF008;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h0010000000000000;
-    ans = 64'hBE8FFFFFFFFFF007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2765455\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h7FDFEFFFFFDFFFFE;
-    z = 64'h3FD00000FFFF7FFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2766069\n");
-    end
-    x = 64'hC06822393DB1B5D9;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h34C001000000003E;
-    ans = 64'h3D2822393DB1B5D7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2766683\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h480FFFFFFFFDFFBF;
-    z = 64'h4340000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2767297\n");
-    end
-    x = 64'h402FFFF803FFFFFF;
-    y = 64'hBFD00000020001FE;
-    z = 64'hCDE000007FFFFFF0;
-    ans = 64'hCDE000007FFFFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2767911\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hBFD0000000000001;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE8000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2768525\n");
-    end
-    x = 64'h381F80000000003F;
-    y = 64'hBC0C24FFA891303C;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2769139\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'hBA10000000000EFE;
-    ans = 64'hFFDFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2769753\n");
-    end
-    x = 64'h4037FFFFFFFFFFFA;
-    y = 64'hC31FFF8FFFFFFFFE;
-    z = 64'hC1700007FFFFFC00;
-    ans = 64'hC367FFAC00200009;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2770367\n");
-    end
-    x = 64'h000FFFFFFFF00006;
-    y = 64'hBFE0000000000001;
-    z = 64'h0000000000000001;
-    ans = 64'h8007FFFFFFF80002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2770981\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hC1C00FFFFFBFFFFF;
-    z = 64'hBFFFFFFFEFC00000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2771595\n");
-    end
-    x = 64'hC03FFFFDFFFFC000;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h51FFFFFFFFC00000;
-    ans = 64'h51FFFFFFFFC00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2772209\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h41F00003FFFFFFFB;
-    z = 64'h4010000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2772823\n");
-    end
-    x = 64'h2DD2641B75C4C4DE;
-    y = 64'hC340800000000100;
-    z = 64'hC020000000000000;
-    ans = 64'hC020000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2773437\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hBFF0000000000000;
-    z = 64'hC340000000000001;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2774051\n");
-    end
-    x = 64'hBFE79A9AE98115B0;
-    y = 64'hBE70000100000000;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFD0CAC739;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2774665\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hC80000000100001F;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2775279\n");
-    end
-    x = 64'h47F000000FFFFFEF;
-    y = 64'h37F0BA5592D6B7C6;
-    z = 64'h3FBFFFFFFF000000;
-    ans = 64'h3FF2BA55A3810D47;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2775893\n");
-    end
-    x = 64'h7FF3FFFFFFFFFFFF;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2776507\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h3420007FFFFFFFFC;
-    z = 64'h4010404000000000;
-    ans = 64'h7420007FFFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2777121\n");
-    end
-    x = 64'h41EBFFEFFFFFFFFF;
-    y = 64'hC000000000000001;
-    z = 64'hC34605A8B553962B;
-    ans = 64'hC34605A99553162B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2777735\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h41CC4B5F23ACBE96;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2778349\n");
-    end
-    x = 64'h8170000103FFFFFE;
-    y = 64'h3FDFFFFFFF00FFFF;
-    z = 64'h22A5204FB3D18829;
-    ans = 64'h22A5204FB3D18829;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2778963\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2779577\n");
-    end
-    x = 64'hC3DFFF003FFFFFFE;
-    y = 64'h7FF000000020003E;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'h7FF800000020003E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2780191\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hC010000000000001;
-    z = 64'hC1DFFBFFFE000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2780805\n");
-    end
-    x = 64'hBFBFFFFEFFFBFFFF;
-    y = 64'hD40FFFFF000003FF;
-    z = 64'hBFB2000002000000;
-    ans = 64'h53DFFFFDFFFC0BFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2781419\n");
-    end
-    x = 64'hC020000000000100;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2782033\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h380010000003FFFE;
-    z = 64'h43F1FFFFBFFFFFFF;
-    ans = 64'h780010000003FFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2782647\n");
-    end
-    x = 64'h466FFFFFF0001FFE;
-    y = 64'hC340000000000000;
-    z = 64'hC15000000008007F;
-    ans = 64'hC9BFFFFFF0001FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2783261\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h802FC00200000000;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'hC02BC001FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2783875\n");
-    end
-    x = 64'hBFF0000001000000;
-    y = 64'h5700000080000003;
-    z = 64'h41C00100000000FF;
-    ans = 64'hD70000008100000B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2784489\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2785103\n");
-    end
-    x = 64'h37E3FFFFFFFFFBFF;
-    y = 64'hBEF3431D1F903239;
-    z = 64'hBCA0000000000000;
-    ans = 64'hBCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2785717\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hFFE0000000000000;
-    z = 64'hBB6FFFBFFFDFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2786331\n");
-    end
-    x = 64'h43C8874EB3D8AEE2;
-    y = 64'hA87FFFFFFFFDFFFF;
-    z = 64'hBFF001FFFFFFFFFE;
-    ans = 64'hBFF001FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2786945\n");
-    end
-    x = 64'hC3500003FFEFFFFE;
-    y = 64'hFFE0000000000001;
-    z = 64'hFFE0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2787559\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hC1EFE007FFFFFFFF;
-    z = 64'hC7F0000008000020;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2788173\n");
-    end
-    x = 64'hBE40F691785FA275;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hB35FFF803FFFFFFF;
-    ans = 64'h7E40F691785FA274;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2788787\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'h4346719A05C360D1;
-    z = 64'h3FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2789401\n");
-    end
-    x = 64'hC7F0991CCB0BBE1F;
-    y = 64'h400FFF7FFFFEFFFE;
-    z = 64'hFFD4000000020000;
-    ans = 64'hFFD4000000020000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2790015\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hFFF0000000000001;
-    z = 64'hC000000000000000;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2790629\n");
-    end
-    x = 64'h423000000002000F;
-    y = 64'hBF5DFF2DE9D3F850;
-    z = 64'h8010000000000001;
-    ans = 64'hC19DFF2DE9D7B852;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2791243\n");
-    end
-    x = 64'h7FEFFFFFFFFFFFFE;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hC2E1C2B66781392C;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2791857\n");
-    end
-    x = 64'h308D3F161CAAD5D4;
-    y = 64'h475FFFFFFFC00FFE;
-    z = 64'h3FEF86854B517225;
-    ans = 64'h3FEF86854B517225;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2792471\n");
-    end
-    x = 64'h47EFFFFFFFFD7FFF;
-    y = 64'h0000000000000000;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2793085\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hBCAFFBFFE0000000;
-    z = 64'hC3FFFFFDFFFFFFF0;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2793699\n");
-    end
-    x = 64'h4010FFFFFF7FFFFF;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hC7E0000040000100;
-    ans = 64'hC7E0000040000100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2794313\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h3FCFFFFFFFFFB800;
-    z = 64'h3FE0000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2794927\n");
-    end
-    x = 64'h402000000003C000;
-    y = 64'h2BBFFFFFE0000003;
-    z = 64'hC3D9F0847445CB73;
-    ans = 64'hC3D9F0847445CB73;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2795541\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h0010000000000000;
-    z = 64'hBFF0000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2796155\n");
-    end
-    x = 64'h3F20003EFFFFFFFF;
-    y = 64'hBFF0000000800020;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'hBF20003F00800217;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2796769\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hB5FFFFFFDFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2797383\n");
-    end
-    x = 64'h3FD0000000010007;
-    y = 64'h3F9FFDFFFFFC0000;
-    z = 64'h043FFFFF00000800;
-    ans = 64'h3F7FFDFFFFFDFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2797997\n");
-    end
-    x = 64'h802C7082F2D15588;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2798611\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hC1800002FFFFFFFF;
-    z = 64'hC3CFFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2799225\n");
-    end
-    x = 64'h37F0000000FFFFFF;
-    y = 64'h3CA0000000000001;
-    z = 64'h3EF4E84F0DAF7946;
-    ans = 64'h3EF4E84F0DAF7946;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2799839\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hBFFFFF0000000020;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2800453\n");
-    end
-    x = 64'h3FFFFFFFEFFFFFDF;
-    y = 64'h405F7FFEFFFFFFFF;
-    z = 64'hBFC8313D186FF150;
-    ans = 64'h406F79F2A0F9E462;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2801067\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2801681\n");
-    end
-    x = 64'h417FFFC040000000;
-    y = 64'h3CA00007FFC00000;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2802295\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h3FD0000000000001;
-    z = 64'hC34FFDFFFFFFFF7F;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2802909\n");
-    end
-    x = 64'hF0C0003FFFFFFFFC;
-    y = 64'hBFC040000FFFFFFE;
-    z = 64'hC018E3FC97500574;
-    ans = 64'h7090404110003FFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2803523\n");
-    end
-    x = 64'hFF0FB3A76863C927;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hFEFFB3A76863C926;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2804137\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hC3E00087FFFFFFFE;
-    z = 64'h480FFFFFFFDFFFF6;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2804751\n");
-    end
-    x = 64'hC80000007F7FFFFF;
-    y = 64'h3FE0000000000000;
-    z = 64'hB64007FFFFFEFFFF;
-    ans = 64'hC7F000007F7FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2805365\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hC8007FFFFFFFDFFF;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2805979\n");
-    end
-    x = 64'h402FFF807FFFFFFF;
-    y = 64'h37FC8B335383047F;
-    z = 64'h4340200000080000;
-    ans = 64'h4340200000080000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2806593\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2807207\n");
-    end
-    x = 64'hC3C0000088000000;
-    y = 64'hC34A8A318C8B3E44;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2807821\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h3FF0000000000000;
-    z = 64'h7FEDFFFFFFBFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2808435\n");
-    end
-    x = 64'hFFFFFE0000000004;
-    y = 64'h4270000000010FFF;
-    z = 64'hB84FFFFF7FF7FFFF;
-    ans = 64'hFFFFFE0000000004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2809049\n");
-    end
-    x = 64'h43A03FFFFFFEFFFF;
-    y = 64'h3FF0000000000001;
-    z = 64'hC000000000000000;
-    ans = 64'h43A03FFFFFFF0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2809663\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hBFAFFFFFFE1FFFFF;
-    z = 64'hB7FFFFFC08000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2810277\n");
-    end
-    x = 64'h47F0000000FFFDFF;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'hC1DFFFFFFFFFFEF6;
-    ans = 64'h4800000000FFFDFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2810891\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h3EAF800000008000;
-    z = 64'h3CA0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2811505\n");
-    end
-    x = 64'h5BEFFFFFFFFFEFFE;
-    y = 64'h7FFFFFFC007FFFFF;
-    z = 64'hC1EFFFFFFEDFFFFF;
-    ans = 64'h7FFFFFFC007FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2812119\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h4000000000000001;
-    z = 64'hBFD0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2812733\n");
-    end
-    x = 64'hBFF80F7B17E98453;
-    y = 64'hC3D6E30A5A94BC09;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2813347\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hBC5E24D175FF8E44;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2813961\n");
-    end
-    x = 64'h4803CCEB031B60A4;
-    y = 64'h796A522F02E82FC6;
-    z = 64'h480C776C5FE298B2;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2814575\n");
-    end
-    x = 64'h403FFDFFFBFFFFFE;
-    y = 64'h4010000000000000;
-    z = 64'hBFF0000000000001;
-    ans = 64'h405FBDFFFBFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2815189\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h401FE00000002000;
-    z = 64'h47E000001FFBFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2815803\n");
-    end
-    x = 64'h0FC0000003FFF7FF;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h3F407BFFFFFFFFFE;
-    ans = 64'h3F407BFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2816417\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h3F2000000000043E;
-    z = 64'h0010000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2817031\n");
-    end
-    x = 64'hBFD000002000FFFE;
-    y = 64'hC8044401C84131E5;
-    z = 64'hBFDFFD7FFFFFFFFF;
-    ans = 64'h47E44401F0CA79B3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2817645\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h4340000000000000;
-    z = 64'hBCA0000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2818259\n");
-    end
-    x = 64'hC1F9782AAEE2F6E6;
-    y = 64'h41F9D1C5D52EC00A;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'hC4048AD7A4DB6198;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2818873\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h41CFFFFEFFFDFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2819487\n");
-    end
-    x = 64'hC18403FFFFFFFFFF;
-    y = 64'h480FFFFFFFFFFFB7;
-    z = 64'hBFE00000000FFFEE;
-    ans = 64'hC9A403FFFFFFFFD1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2820101\n");
-    end
-    x = 64'h800FFFFFFEF7FFFE;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2820715\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h40DFE00000400000;
-    z = 64'hC00122D1E9DB54BA;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2821329\n");
-    end
-    x = 64'h533000000003FFF7;
-    y = 64'h7FE0000000000001;
-    z = 64'hC1E075D8BA1D5302;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2821943\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h41F0000FFFFF7FFF;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2822557\n");
-    end
-    x = 64'h4000000001DFFFFF;
-    y = 64'h473FFFFFFFFF2000;
-    z = 64'h58CFFFEFFFEFFFFF;
-    ans = 64'h58CFFFEFFFEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2823171\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2823785\n");
-    end
-    x = 64'hBCA308379D8DFF8B;
-    y = 64'h41EFFFFFFFFFDEFE;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFFFFD9EF90C3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2824399\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h7FF0000000000001;
-    z = 64'hBFAB85887638758B;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2825013\n");
-    end
-    x = 64'h3F90000FFFFF8000;
-    y = 64'h3FB000FFFFEFFFFF;
-    z = 64'h412FEFFFFFFE0000;
-    ans = 64'h412FF000007E0880;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2825627\n");
-    end
-    x = 64'hB0BEFFFFFFF7FFFF;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2826241\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h3FD0003FFFFFC000;
-    z = 64'h43DFFFE000000006;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2826855\n");
-    end
-    x = 64'hB7FFFFDFFFFFF7FF;
-    y = 64'h8000000000000000;
-    z = 64'h3FBFFFFFFDFFDFFF;
-    ans = 64'h3FBFFFFFFDFFDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2827469\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hBF6020000003FFFE;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2828083\n");
-    end
-    x = 64'h411FFFFFFFFDFEFE;
-    y = 64'hB806E5E85D3FD5BC;
-    z = 64'hC02FFFFFFFFF7FFD;
-    ans = 64'hC02FFFFFFFFF7FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2828697\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2829311\n");
-    end
-    x = 64'h43CFFF7FDFFFFFFE;
-    y = 64'h41FFFEFFEFFFFFFF;
-    z = 64'h4010000000000000;
-    ans = 64'h45DFFE7FD401400D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2829925\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h8010000000000000;
-    z = 64'h46C5C698A716C584;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2830539\n");
-    end
-    x = 64'hAF408000FFFFFFFE;
-    y = 64'hBFE00000100007FF;
-    z = 64'hBFF000001FFFFFFB;
-    ans = 64'hBFF000001FFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2831153\n");
-    end
-    x = 64'h3F5000000000FEFF;
-    y = 64'h8010000000000001;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2831767\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hC3FFFFFFFF801000;
-    z = 64'h000FFFFFFFDFFC00;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2832381\n");
-    end
-    x = 64'hC35FFF000000003F;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h79300001001FFFFE;
-    ans = 64'h79300001001FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2832995\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hBFF003FE00000000;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2833609\n");
-    end
-    x = 64'h00200000003FFFBE;
-    y = 64'h41FFFFFFE0000400;
-    z = 64'h3FC0040000200000;
-    ans = 64'h3FC0040000200000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2834223\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hBCA0000000000001;
-    z = 64'h8000000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2834837\n");
-    end
-    x = 64'hC340003FFFFFFFFF;
-    y = 64'hC570000004FFFFFF;
-    z = 64'h4000000000000001;
-    ans = 64'h48C00040050013FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2835451\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h801400000000FFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2836065\n");
-    end
-    x = 64'h4584000000000080;
-    y = 64'h4017FFFFEFFFFFFF;
-    z = 64'h47FE1280A05363FA;
-    ans = 64'h47FE1280A05453FA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2836679\n");
-    end
-    x = 64'h00200010000FFFFE;
-    y = 64'hBFD0000000000000;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2837293\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h41C73BE56BB37EBE;
-    z = 64'hC1DFFFFFFFE7FFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2837907\n");
-    end
-    x = 64'hFFFBF1F5EF2E2892;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hC020000102000000;
-    ans = 64'hFFFBF1F5EF2E2892;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2838521\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h801FAAF2E4C19308;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2839135\n");
-    end
-    x = 64'hC1D000000003FFFF;
-    y = 64'h3C4807B2AD0CFCE1;
-    z = 64'hBFEBD757A7E46DCA;
-    ans = 64'hBFEBD757A964E8F5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2839749\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hBFE0000000000000;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2840363\n");
-    end
-    x = 64'h8A400000007E0000;
-    y = 64'h400FF8000000FFFE;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h3FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2840977\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h40DBFFFFFFFFF7FE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2841591\n");
-    end
-    x = 64'h47FB58DEE3FCB3A6;
-    y = 64'hC7E000000003FDFE;
-    z = 64'h4000000000000022;
-    ans = 64'hCFEB58DEE403866F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2842205\n");
-    end
-    x = 64'hC01FFF0000000001;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h401FFEFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2842819\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hB7E24093523AA87A;
-    z = 64'hC030000040020000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2843433\n");
-    end
-    x = 64'h40354998F7F1DCE5;
-    y = 64'hBFF0000000000001;
-    z = 64'hCC1083FFFFFFFFFE;
-    ans = 64'hCC1083FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2844047\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hC24132F19425406D;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2844661\n");
-    end
-    x = 64'h3F8FF7FFFFFF7FFE;
-    y = 64'h3FD84FD0BC13D2AD;
-    z = 64'h37FD165AFFD1797D;
-    ans = 64'h3F7849BCC7E46C78;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2845275\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2845889\n");
-    end
-    x = 64'h40515FAC435403A8;
-    y = 64'h48FAAF3AB115872C;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h495CF9BE14A322EB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2846503\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hC000000000000000;
-    z = 64'h000FFFE000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2847117\n");
-    end
-    x = 64'hC270000007FFFFC0;
-    y = 64'hFFFFFFFFFEFFFFFF;
-    z = 64'hC0102A7E0F9CEE45;
-    ans = 64'hFFFFFFFFFEFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2847731\n");
-    end
-    x = 64'hB441FFFFFFFFFFFE;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h3461FFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2848345\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hCF52AA0F637D5364;
-    z = 64'hB8000003FFFEFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2848959\n");
-    end
-    x = 64'h401FDFFFFFFFFFFC;
-    y = 64'hC010000000000000;
-    z = 64'hC3DCDE60E50FBCE9;
-    ans = 64'hC3DCDE60E50FBCE9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2849573\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h3FDC2F8EE87082D3;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2850187\n");
-    end
-    x = 64'h402000002000003F;
-    y = 64'hA8D00FFFFFFFDFFF;
-    z = 64'h468000FFFFFFEFFE;
-    ans = 64'h468000FFFFFFEFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2850801\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2851415\n");
-    end
-    x = 64'hBFCC09699F03D2D5;
-    y = 64'h7FD9D6B397AD3382;
-    z = 64'h3FE0000000000000;
-    ans = 64'hFFB6A376D01D6230;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2852029\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h405001FFDFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2852643\n");
-    end
-    x = 64'h4043FFFFFFFFFFFF;
-    y = 64'h38002D4FB3860015;
-    z = 64'h3FB0020000000200;
-    ans = 64'h3FB0020000000200;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2853257\n");
-    end
-    x = 64'hB33FFFFFE0000000;
-    y = 64'hC340000000000001;
-    z = 64'h8000000000000000;
-    ans = 64'h368FFFFFE0000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2853871\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hC00FFFFFFFF07FFE;
-    z = 64'h47DFFDFFFFDFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2854485\n");
-    end
-    x = 64'h403FFFFFC000001E;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h41308D4A571E0907;
-    ans = 64'hC39FFFFFBFFFBDE7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2855099\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h400D3244B30A626D;
-    z = 64'hC010000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2855713\n");
-    end
-    x = 64'hC3DFFFFF001FFFFF;
-    y = 64'hBF80000002200000;
-    z = 64'hBCAE00007FFFFFFF;
-    ans = 64'h436FFFFF045FFFDD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2856327\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hFFE0000000000001;
-    z = 64'h4340000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2856941\n");
-    end
-    x = 64'h407000001FFFF7FF;
-    y = 64'hC0178722E8E2710F;
-    z = 64'h3FD0000000000001;
-    ans = 64'hC097862317F0AB1C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2857555\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h3FB90979A89594A7;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2858169\n");
-    end
-    x = 64'hBE2000000010001F;
-    y = 64'h3F0000FFFF800000;
-    z = 64'h402FFFC0000FFFFF;
-    ans = 64'h402FFFC0000FFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2858783\n");
-    end
-    x = 64'h3F14E7AD5BFBD3E7;
-    y = 64'hFFF0000000000000;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2859397\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'h316FFFFFFDFFF7FE;
-    z = 64'h7FF000000FFFFFF6;
-    ans = 64'h7FF800000FFFFFF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2860011\n");
-    end
-    x = 64'h3CAFFFFFFFFF0040;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h8000003DFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2860625\n");
-    end
-    x = 64'h7FF0000000000000;
-    y = 64'hC1F8DA003FDA2EDA;
-    z = 64'hC000000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2861239\n");
-    end
-    x = 64'hC03000000FFFFFBE;
-    y = 64'h43F0000000040FFF;
-    z = 64'h47B0000400100000;
-    ans = 64'h47B0000400100000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2861853\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h0000000000000000;
-    z = 64'h4010000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2862467\n");
-    end
-    x = 64'h36CFBFFFFFFFFFF6;
-    y = 64'h801FE000000000FE;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2863081\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h0000000000000001;
-    z = 64'h4010100000000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2863695\n");
-    end
-    x = 64'hFFF97B52C843D305;
-    y = 64'h001A888ACADE5D0B;
-    z = 64'hD8A00080007FFFFF;
-    ans = 64'hFFF97B52C843D305;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2864309\n");
-    end
-    x = 64'hBFFFFFE000001FFF;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2864923\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h3E34C388504B59C2;
-    z = 64'hA8E00800000003FF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2865537\n");
-    end
-    x = 64'h469114017D84F70F;
-    y = 64'h0010000000000000;
-    z = 64'hBFC00000001FFEFE;
-    ans = 64'hBFC00000001FFEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2866151\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h43FFFFC3FFFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2866765\n");
-    end
-    x = 64'hBE79FFFFFFFFFFFE;
-    y = 64'h434AD55EDC5984FD;
-    z = 64'h0023FFFFFFFF7FFE;
-    ans = 64'hC1D5CD5D1308BC0C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2867379\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2867993\n");
-    end
-    x = 64'h31BF7FFFFFFEFFFF;
-    y = 64'h41F62EE647FE43C3;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h33C5D62AAEDD993C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2868607\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h3CA0000000000000;
-    z = 64'hBFB01FAF3AFF1ABA;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2869221\n");
-    end
-    x = 64'h3D0000000800FFFF;
-    y = 64'h41CEFFFFFFBFFFFE;
-    z = 64'h41D8297E5EAC04D3;
-    ans = 64'h41D8297E5EAC04F2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2869835\n");
-    end
-    x = 64'h480C000000000002;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h44CC000020000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2870449\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hBF8E1FE03410C3CD;
-    z = 64'hC34001FFFFFFFFFB;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2871063\n");
-    end
-    x = 64'h5240000000000FFD;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h3FF00FFFFFFFFFDF;
-    ans = 64'h4F00000000000FFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2871677\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hFFEFFFBFFFFC0000;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2872291\n");
-    end
-    x = 64'hF8A0000002001FFF;
-    y = 64'h43DFFFFF00000002;
-    z = 64'hC34FFFFE00001FFF;
-    ans = 64'hFC8FFFFF04003FE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2872905\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2873519\n");
-    end
-    x = 64'hBFF00000800003FF;
-    y = 64'h60F0400000080000;
-    z = 64'h0010000000000000;
-    ans = 64'hE0F040008208040F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2874133\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h41DFFFFFEEFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2874747\n");
-    end
-    x = 64'h3CA27F59AF996B9F;
-    y = 64'h4D6FFFFFFFFF7FFE;
-    z = 64'h1F9FFFFFFFDEFFFF;
-    ans = 64'h4A227F59AF9921A0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2875361\n");
-    end
-    x = 64'hBF9FFFFFFFE00002;
-    y = 64'h3FE0000000000001;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2875975\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hC1FFFFFC0007FFFE;
-    z = 64'hBFEFFEFFFFFFFFBF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2876589\n");
-    end
-    x = 64'h3F7FBFFFFFE00000;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h3817BF5A3F991426;
-    ans = 64'h3F7FBFFFFFDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2877203\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h4FF2AD354C273C4F;
-    z = 64'hBFE0000000000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2877817\n");
-    end
-    x = 64'h45AFFFFFFFDEFFFF;
-    y = 64'hBC3DFFFFFFFFFFEF;
-    z = 64'h800FF7FFFFFFFFFB;
-    ans = 64'hC1FDFFFFFFE10FEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2878431\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h3FF0000000000001;
-    z = 64'h3FF0000000000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2879045\n");
-    end
-    x = 64'hBFD000000100000F;
-    y = 64'hC09A69FA93AE1A05;
-    z = 64'h0000000000000001;
-    ans = 64'h407A69FA9554B9C7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2879659\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hC7E10C2C8E90FC29;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2880273\n");
-    end
-    x = 64'h646FFFFFFFEFFF7F;
-    y = 64'hC203FEEF05195503;
-    z = 64'hC010000FFFFFFFDE;
-    ans = 64'hE683FEEF050F553B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2880887\n");
-    end
-    x = 64'h42E8000000080000;
-    y = 64'h4000000000000000;
-    z = 64'h4010000000000001;
-    ans = 64'h42F8000000080040;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2881501\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h800138DCFF1B5E8A;
-    z = 64'hFFEFFFFFDFFFDFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2882115\n");
-    end
-    x = 64'hC1DFFFFFFFFFFFFF;
-    y = 64'h4000000000000001;
-    z = 64'h41FF000000001FFF;
-    ans = 64'h41EE000000003FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2882729\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hBFD0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2883343\n");
-    end
-    x = 64'h3FFC50269594D1EA;
-    y = 64'h80100000000FFFBF;
-    z = 64'hC3C5A4DEA80A7E9C;
-    ans = 64'hC3C5A4DEA80A7E9C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2883957\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h4010000000000000;
-    z = 64'h3FE0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2884571\n");
-    end
-    x = 64'h9210003FFFFFFFEF;
-    y = 64'hBFCFFFFFFFFFFFCF;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2885185\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h4010000000000001;
-    z = 64'h380FFFFFFC00001F;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2885799\n");
-    end
-    x = 64'h3FE000000002FFFE;
-    y = 64'hBF6040FFFFFFFFFF;
-    z = 64'hBFEFFF0001FFFFFF;
-    ans = 64'hBFF00390410000C3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2886413\n");
-    end
-    x = 64'h3F1FFFFFFF7FBFFF;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h401000FFFFFFFBFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2887027\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hAD0FFFBFFFFFFFFF;
-    z = 64'hC1C30CFDF166F3A9;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2887641\n");
-    end
-    x = 64'hBFC88F53F742F741;
-    y = 64'h4340000000000000;
-    z = 64'hBCADA4273450D0D3;
-    ans = 64'hC3188F53F742F741;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2888255\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h4020000000FFDFFF;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2888869\n");
-    end
-    x = 64'h3FF00040000000FF;
-    y = 64'h41DFFFFFFFFFFE02;
-    z = 64'hAB00000000012000;
-    ans = 64'h41E0004000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2889483\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2890097\n");
-    end
-    x = 64'hC7E003FFFDFFFFFF;
-    y = 64'hB97BF69F52A53CD4;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2890711\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h7FE0000000000000;
-    z = 64'hC010000000006FFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2891325\n");
-    end
-    x = 64'h420FFFFFFFE07FFF;
-    y = 64'h002FFF7FFFFFFFFB;
-    z = 64'hC01FFF3FFFFFFFFF;
-    ans = 64'hC01FFF3FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2891939\n");
-    end
-    x = 64'h43BAE28442A43690;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2892553\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h47E90072420C8EAB;
-    z = 64'hC3C2000001000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2893167\n");
-    end
-    x = 64'hBFE0000003FFFFDF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hB0E0801FFFFFFFFF;
-    ans = 64'hFFE0000003FFFFDE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2893781\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hFFDFFFFFFFEFFFF7;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2894395\n");
-    end
-    x = 64'hBFCF7FFFFFFF0000;
-    y = 64'hC01AB4C668B81BFF;
-    z = 64'hCCC7FFFFFFFFFBFE;
-    ans = 64'hCCC7FFFFFFFFFBFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2895009\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2895623\n");
-    end
-    x = 64'hC02FE01000000000;
-    y = 64'hC6DFFFFDFFFFFFFD;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2896237\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'hBFD0080000200000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2896851\n");
-    end
-    x = 64'hB7E0000000FFFFDE;
-    y = 64'hC8000040FFFFFFFF;
-    z = 64'h3CA25A25EB808CF6;
-    ans = 64'h3FF00041010003EE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2897465\n");
-    end
-    x = 64'h600FFFFFFFFFC002;
-    y = 64'h8000000000000001;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2898079\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h400000000000002F;
-    z = 64'h380DF17822F732BD;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2898693\n");
-    end
-    x = 64'hB11AD0B8DA26800D;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hC780000000000017;
-    ans = 64'hC780000000000017;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2899307\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h400E791D9DD9BC2F;
-    z = 64'h8010000000000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2899921\n");
-    end
-    x = 64'h81A0000FBFFFFFFF;
-    y = 64'h4343FFFFFFFFFF7E;
-    z = 64'h401FFF800000007E;
-    ans = 64'h401FFF800000007E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2900535\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h8010000000000001;
-    z = 64'h3CA0000000000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2901149\n");
-    end
-    x = 64'h4D8000004000007F;
-    y = 64'hBF60000010000001;
-    z = 64'hC340000000000001;
-    ans = 64'hCCF00000500000C0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2901763\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h3DA00000002001FF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2902377\n");
-    end
-    x = 64'h3FDFFFE00000FFFE;
-    y = 64'h5B962D44BC128284;
-    z = 64'hC1F37FD701772207;
-    ans = 64'h5B862D2E8ECE77DA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2902991\n");
-    end
-    x = 64'h480F000000000006;
-    y = 64'hBCA0000000000000;
-    z = 64'h3FE0000000000001;
-    ans = 64'hC4BF000000000006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2903605\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hC1F17FFFFFFFFFFF;
-    z = 64'hC02041FFFFFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2904219\n");
-    end
-    x = 64'h4028629AD7424975;
-    y = 64'hBCA0000000000001;
-    z = 64'h3CA00001FFFFFC00;
-    ans = 64'hBCD6629A974249F7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2904833\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hC1DFFFFFFE000200;
-    z = 64'h8000000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2905447\n");
-    end
-    x = 64'hBFDF00000001FFFF;
-    y = 64'hC80FFFFFFFFFFDBF;
-    z = 64'hC7B978FC409BA3FD;
-    ans = 64'h47FD68703BF84390;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2906061\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hBFD0000000000000;
-    z = 64'h0010000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2906675\n");
-    end
-    x = 64'hC1ED805BD15C139B;
-    y = 64'h28901FFFFFFFFFFD;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2907289\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hBFD0000000000001;
-    z = 64'h4030000800200000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2907903\n");
-    end
-    x = 64'h37EFFFFFBC000000;
-    y = 64'hF040000200000FFF;
-    z = 64'hBFAFFFFFF7FEFFFE;
-    ans = 64'hE8400001DE000BBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2908517\n");
-    end
-    x = 64'hBFFFFFF5FFFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FF7FFFAFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2909131\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h40200000FFFFDFFE;
-    z = 64'hAC4F7052B43B96D6;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2909745\n");
-    end
-    x = 64'hC3FC000040000000;
-    y = 64'hBFE0000000000000;
-    z = 64'hBF9FFFFFBFFFFBFF;
-    ans = 64'h43EC000040000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2910359\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h3CA00003FFFFFFF6;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2910973\n");
-    end
-    x = 64'h39CEA5268438722C;
-    y = 64'h3E4FDFFDFFFFFFFF;
-    z = 64'h3FE0000000FFFFFC;
-    ans = 64'h3FE0000000FFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2911587\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2912201\n");
-    end
-    x = 64'h802FFFC000003FFF;
-    y = 64'h3D700000000FFFF8;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2912815\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hBFF0000000000000;
-    z = 64'h3FBF00000000001F;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2913429\n");
-    end
-    x = 64'h47E03FFFFFFFF800;
-    y = 64'hC00001007FFFFFFF;
-    z = 64'h400000000008001E;
-    ans = 64'hC7F0410481FFF7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2914043\n");
-    end
-    x = 64'h38100003FEFFFFFF;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2914657\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h5EBDA64B1F6C454A;
-    z = 64'hBFE000000800001F;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2915271\n");
-    end
-    x = 64'h41FFDFFFFF7FFFFE;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hBC639470CFAB75A4;
-    ans = 64'hC20FDFFFFF7FFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2915885\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hBFF83A1ED571DC64;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2916499\n");
-    end
-    x = 64'h802000004000FFFF;
-    y = 64'hC00010003FFFFFFE;
-    z = 64'h80110003FFFFFFFE;
-    ans = 64'h00279FFF008203FB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2917113\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hC000000000000001;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2917727\n");
-    end
-    x = 64'hFFEFFFFFFFFFF01F;
-    y = 64'h3FDDF7FFFFFFFFFE;
-    z = 64'hC000000000000000;
-    ans = 64'hFFDDF7FFFFFFF11F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2918341\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hBF8F7FFFFFFFFFBF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2918955\n");
-    end
-    x = 64'hC024C21357A48D0D;
-    y = 64'hFFF0000000003FF7;
-    z = 64'h41D00017FFFFFFFE;
-    ans = 64'hFFF8000000003FF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2919569\n");
-    end
-    x = 64'h445169266A3DEB8C;
-    y = 64'hC010000000000001;
-    z = 64'h3CA0000000000000;
-    ans = 64'hC47169266A3DEB8D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2920183\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h7FDFFF000007FFFF;
-    z = 64'hBFCFFFFFFFFF800E;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2920797\n");
-    end
-    x = 64'h43DFFF83FFFFFFFF;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h41E0007FFF000000;
-    ans = 64'hC40FFF83FFFBFFDE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2921411\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h47EFFFFFFFF7FFFE;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2922025\n");
-    end
-    x = 64'h3E400001FFFBFFFF;
-    y = 64'h3FE77A2166CACFDC;
-    z = 64'h381359BB509306FE;
-    ans = 64'h3E377A2456091E2C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2922639\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hC340000000000000;
-    z = 64'hFFF0000000000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2923253\n");
-    end
-    x = 64'hBFD000000004007F;
-    y = 64'h3FDFFFFBFFFFFBFF;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFF1FFFFC0007FD1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2923867\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h3CACE893AA2E59D8;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2924481\n");
-    end
-    x = 64'h3FB0B636B6EA69D3;
-    y = 64'h2600000007FFFFBE;
-    z = 64'h3601FFFFFFFFFF7F;
-    ans = 64'h3601FFFFFFFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2925095\n");
-    end
-    x = 64'hC550000080000FFF;
-    y = 64'hFFE0000000000000;
-    z = 64'h0010000000000001;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2925709\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h43FFFFFFF000001E;
-    z = 64'h3FF0400200000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2926323\n");
-    end
-    x = 64'h41EFFFFFFC000001;
-    y = 64'hFFE0000000000001;
-    z = 64'h407FC00000000007;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2926937\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'h46452C93D5A9BE1B;
-    z = 64'h4340000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2927551\n");
-    end
-    x = 64'h3FA4BFCB07A2886E;
-    y = 64'h3B1F43C73803FA4C;
-    z = 64'h3FB200FFFFFFFFFF;
-    ans = 64'h3FB200FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2928165\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hFFE0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2928779\n");
-    end
-    x = 64'h20BFFFFF7EFFFFFE;
-    y = 64'h43DFFFE000000100;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2929393\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hFFF0000000000001;
-    z = 64'hC7E0000001FFFFEF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2930007\n");
-    end
-    x = 64'h400D2E087C272421;
-    y = 64'h58200401FFFFFFFE;
-    z = 64'hC3C266610B3228BB;
-    ans = 64'h583D3557A4073D6B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2930621\n");
-    end
-    x = 64'h47EEFFFFFFBFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2931235\n");
-    end
-    x = 64'h7FF0000000000001;
-    y = 64'hC054A510735203C8;
-    z = 64'hC3EFFFFFFFFE01FF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2931849\n");
-    end
-    x = 64'hC34000001FFFFDFF;
-    y = 64'h0000000000000000;
-    z = 64'h7FE0000000011FFF;
-    ans = 64'h7FE0000000011FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2932463\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hBFEFFFFF7FFFFFFE;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2933077\n");
-    end
-    x = 64'h1440D7A99B79C195;
-    y = 64'h3D6000000000100F;
-    z = 64'hC3DFF800007FFFFF;
-    ans = 64'hC3DFF800007FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2933691\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2934305\n");
-    end
-    x = 64'hBFC72574439F0F8D;
-    y = 64'hBCCE99A34A3E0638;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2934919\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h0010000000000000;
-    z = 64'hC1DF000000000FFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2935533\n");
-    end
-    x = 64'h801FFFFFFBFFFFEF;
-    y = 64'hC340440000000000;
-    z = 64'h40808FFFFFFFFFFE;
-    ans = 64'h40808FFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2936147\n");
-    end
-    x = 64'hBFF60F1DF5DA594A;
-    y = 64'h0010000000000001;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2936761\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h3FE0000000110000;
-    z = 64'h3FCFFFFFFFFDFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2937375\n");
-    end
-    x = 64'hBB212651C58F296A;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h7FD3E0DB33B0C462;
-    ans = 64'h7FD3E0DB33B0C462;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2937989\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h43C0000000001EFE;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2938603\n");
-    end
-    x = 64'h402AFC152BB76278;
-    y = 64'hC73F7FFFFFFEFFFF;
-    z = 64'hBDD0000080FFFFFF;
-    ans = 64'hC77A9024D707AD0D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2939217\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h3CA0000000000001;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2939831\n");
-    end
-    x = 64'h3CF0100FFFFFFFFE;
-    y = 64'h3E5FDFFF7FFFFFFE;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2940445\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h7FDFFFFE04000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2941059\n");
-    end
-    x = 64'hC3CFCFFFFFFFFFFF;
-    y = 64'h4043FFFFFFFFBFFF;
-    z = 64'hC010003FFFFFFFFE;
-    ans = 64'hC423E1FFFFFFC05E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2941673\n");
-    end
-    x = 64'hC1E499D3794E5EF8;
-    y = 64'h3FD0000000000000;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2942287\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h3F0000000080FFFF;
-    z = 64'h7FF000000F7FFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2942901\n");
-    end
-    x = 64'h41EFFFFFFFFEFF7F;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h480F7FC000000000;
-    ans = 64'h480F7FC000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2943515\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hC426783221EF473C;
-    z = 64'h4000000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2944129\n");
-    end
-    x = 64'h7FE01FFFFFFFDFFF;
-    y = 64'h434FFFF00001FFFE;
-    z = 64'h381FF7FFFFF7FFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2944743\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h3FE0000000000000;
-    z = 64'hC010000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2945357\n");
-    end
-    x = 64'hF3ABFFF7FFFFFFFF;
-    y = 64'hBD5EFFBFFFFFFFFE;
-    z = 64'hBCA0000000000001;
-    ans = 64'h711B1FC0400FFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2945971\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h434FFFFEFFFFFFFD;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2946585\n");
-    end
-    x = 64'hBFA0000001FFF7FF;
-    y = 64'h3E32C8772CF7A110;
-    z = 64'hC150004000200000;
-    ans = 64'hC150004000200000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2947199\n");
-    end
-    x = 64'hC6BFFFFDFFBFFFFE;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2947813\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h407BE20CE424F639;
-    z = 64'h2380003FFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2948427\n");
-    end
-    x = 64'h4E4FFF7FFFEFFFFF;
-    y = 64'h3FF0000000000001;
-    z = 64'h4000000000101000;
-    ans = 64'h4E4FFF7FFFF00001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2949041\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hBFFFFFFFFFFF01FF;
-    z = 64'h3FF0000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2949655\n");
-    end
-    x = 64'h403FFBFFFFFFFDFF;
-    y = 64'hFCAF4DA8CA8EDCB6;
-    z = 64'h3FFFFFFFFFEFFFBF;
-    ans = 64'hFCFF49BF157588E5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2950269\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'hC000000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2950883\n");
-    end
-    x = 64'hBFD0000007FF7FFF;
-    y = 64'hFFDFFFEFFFFFFFEF;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h7FBFFFF00FFEF7EE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2951497\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h4000000000000001;
-    z = 64'h3FEFFFFFFBEFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2952111\n");
-    end
-    x = 64'hF6C7FBFFFFFFFFFE;
-    y = 64'h3F0FF80000200000;
-    z = 64'h38200000000008FE;
-    ans = 64'hF5E7F6010017FBFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2952725\n");
-    end
-    x = 64'hC01FF003FFFFFFFE;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC350000000000007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2953339\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hBCA8A69E52F6A7C2;
-    z = 64'h3FE0002000FFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2953953\n");
-    end
-    x = 64'hC670003BFFFFFFFF;
-    y = 64'h4010000000000000;
-    z = 64'h3F4000008FFFFFFF;
-    ans = 64'hC690003BFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2954567\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hBFCBFFFFFFFFFFFE;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2955181\n");
-    end
-    x = 64'h2E85F2326ACAC7CD;
-    y = 64'h40200000100000FF;
-    z = 64'h390000001FFFC000;
-    ans = 64'h390000001FFFC000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2955795\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2956409\n");
-    end
-    x = 64'hC7F0005FFFFFFFFE;
-    y = 64'h001FFFFFDFFFEFFF;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h8820005FEFFF97FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2957023\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h4340000000000000;
-    z = 64'hBFF587068DC3E0AA;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2957637\n");
-    end
-    x = 64'hB9FFF4E99D3A4249;
-    y = 64'hF4D0007FFBFFFFFF;
-    z = 64'h402000000000083E;
-    ans = 64'h6EDFF5E93C89F1B2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2958251\n");
-    end
-    x = 64'hE2A0000041FFFFFF;
-    y = 64'h4340000000000001;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hE5F0000042000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2958865\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h7FFBCB3137A93FEB;
-    z = 64'hBFEFFFF8001FFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2959479\n");
-    end
-    x = 64'h37FFFFFFFFFBFFBE;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h41FFFFFFFFFDFFF7;
-    ans = 64'h41FFFFFFFFFDFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2960093\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h3DCC0000FFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2960707\n");
-    end
-    x = 64'h3ED4000000040000;
-    y = 64'h47F0000000006FFF;
-    z = 64'hBFE26C979F9A687F;
-    ans = 64'h46D4000000048BFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2961321\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h7FE0000000000001;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2961935\n");
-    end
-    x = 64'hC390000001000000;
-    y = 64'h74AAA02E49FFE7E3;
-    z = 64'h8000000000000000;
-    ans = 64'hF84AA02E4BA9EAC8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2962549\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h5D7000001000007F;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2963163\n");
-    end
-    x = 64'hC0200007FFFFFDFF;
-    y = 64'h40036DCAC049B7DE;
-    z = 64'h43D2000001FFFFFF;
-    ans = 64'h43D2000001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2963777\n");
-    end
-    x = 64'hE93FFE0000000002;
-    y = 64'h7FF0000000000000;
-    z = 64'hC010000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2964391\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h531002FFFFFFFFFF;
-    z = 64'hA74FF7F000000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2965005\n");
-    end
-    x = 64'h47EFFFC000000002;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'hC150000020040000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2965619\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hC34FFFFFFFFFE3FF;
-    z = 64'h3FD0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2966233\n");
-    end
-    x = 64'hC3DBE28DD099AC7E;
-    y = 64'h407FFFFFFFFFFFFE;
-    z = 64'h37FFFE0000FFFFFE;
-    ans = 64'hC46BE28DD099AC7C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2966847\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h8000000000000000;
-    z = 64'hBFE0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2967461\n");
-    end
-    x = 64'h41D000000000001D;
-    y = 64'h3EFFFEBFFFFFFFFF;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2968075\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hC030000003FFF7FF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2968689\n");
-    end
-    x = 64'hCCD1FFFFFFFFF7FF;
-    y = 64'h47B00000DFFFFFFF;
-    z = 64'hC03000000001000E;
-    ans = 64'hD4920000FBFFF7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2969303\n");
-    end
-    x = 64'h3807FFFF7FFFFFFE;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2969917\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hCC3FFFFFFFFFFBEF;
-    z = 64'hCF4FFFFFFFFC0008;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2970531\n");
-    end
-    x = 64'h480FFFC000000200;
-    y = 64'h8010000000000001;
-    z = 64'hBD11000000000001;
-    ans = 64'hBD11000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2971145\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hC0B16FFAF4B669F3;
-    z = 64'h3CA0000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2971759\n");
-    end
-    x = 64'hABFFFEFFFC000000;
-    y = 64'hBDD000008000007F;
-    z = 64'hC0EFFD0000000000;
-    ans = 64'hC0EFFD0000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2972373\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hBFD0000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2972987\n");
-    end
-    x = 64'h41CFE0000FFFFFFF;
-    y = 64'h7FFE000003FFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FFE000003FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2973601\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hBCA0000000000001;
-    z = 64'hC00800001FFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2974215\n");
-    end
-    x = 64'hBCABFBFFFFFFFFFF;
-    y = 64'h3FF087050E4FE191;
-    z = 64'h3FC0000024000000;
-    ans = 64'h3FC0000023FFFFF9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2974829\n");
-    end
-    x = 64'h0149F402042DF1CE;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2975443\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFEEF;
-    z = 64'h41FD601EC095C9B3;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2976057\n");
-    end
-    x = 64'h41D3E7CF94A31274;
-    y = 64'hBFD0000000000000;
-    z = 64'h3FB000000FFBFFFF;
-    ans = 64'hC1B3E7CF94931274;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2976671\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hB81F800000100000;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2977285\n");
-    end
-    x = 64'hC1C00001FFFFFBFE;
-    y = 64'hB7FFFFFFFFFFB800;
-    z = 64'hC448000000001FFF;
-    ans = 64'hC448000000001FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2977899\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2978513\n");
-    end
-    x = 64'h3FFFEFFFFE000000;
-    y = 64'hC7F76493330323AA;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'hC80758E0E7F358E5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2979127\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hBFE0000000000000;
-    z = 64'h47EFFFE000000001;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2979741\n");
-    end
-    x = 64'hEFF00000000077FF;
-    y = 64'hBADBE97EB9C9AE4B;
-    z = 64'h3817B654678C79D0;
-    ans = 64'h6ADBE97EB9CA7FA0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2980355\n");
-    end
-    x = 64'hC2A4F3FF01FF246C;
-    y = 64'hBFE0000000000001;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h4294F3FF01FF206D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2980969\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h43FFFFC0000000FF;
-    z = 64'h41D0000000003FFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2981583\n");
-    end
-    x = 64'h52FCE5A153E7E2E9;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hBCAFFFFFFFFE7FFF;
-    ans = 64'hD2FCE5A153E7E2E7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2982197\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hA8527BA8C2664DC8;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2982811\n");
-    end
-    x = 64'hC01D3A4BBE35A328;
-    y = 64'h380FFFBFFFFFFFDE;
-    z = 64'h3FD8000080000000;
-    ans = 64'h3FD8000080000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2983425\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hBFF0000000000001;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2984039\n");
-    end
-    x = 64'h4E3FFFFFFEFFFF00;
-    y = 64'h55E0007F7FFFFFFF;
-    z = 64'h4340000000000000;
-    ans = 64'h6430007F7F7FFB83;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2984653\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hBFD0003FFBFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2985267\n");
-    end
-    x = 64'h3800000000000006;
-    y = 64'hC7EFF00000001FFE;
-    z = 64'hBCA0000001FFFFFF;
-    ans = 64'hBFFFF0000000200A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2985881\n");
-    end
-    x = 64'hBC5FFFFFFFFE0800;
-    y = 64'hC000000000000000;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2986495\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hC05FFFFFFFDFFFF7;
-    z = 64'h403FBFFFFFFDFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2987109\n");
-    end
-    x = 64'hC56E00AC42169CC5;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h47E0004000001FFF;
-    ans = 64'h47E0004000009802;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2987723\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hC0100003FFFFFFDF;
-    z = 64'h0000000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2988337\n");
-    end
-    x = 64'hBF6FFC8000000000;
-    y = 64'h3B4FFFFBFFFBFFFF;
-    z = 64'h41FB680E63FF69F2;
-    ans = 64'h41FB680E63FF69F2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2988951\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hC010000000000000;
-    z = 64'h8010000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2989565\n");
-    end
-    x = 64'h7FF4000003FFFFFF;
-    y = 64'h80007FFFFFFFFFFD;
-    z = 64'h4010000000000001;
-    ans = 64'h7FFC000003FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2990179\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hC3C2415F61A098C3;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2990793\n");
-    end
-    x = 64'h3F9047FFFFFFFFFF;
-    y = 64'hC1E00000008000FE;
-    z = 64'hBF9EFFF7FFFFFFFF;
-    ans = 64'hC180480000C040F1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2991407\n");
-    end
-    x = 64'hC8501000003FFFFF;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hBFD0000000000001;
-    ans = 64'h48801000003FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2992021\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h3810000020000007;
-    z = 64'h3FE47701E81BB120;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2992635\n");
-    end
-    x = 64'hBCAFF7FFFFFFFFFF;
-    y = 64'hC340000000000001;
-    z = 64'h3FF003FFFFFFFFEF;
-    ans = 64'h4007FDFFFFFFFFF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2993249\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hC020000000000104;
-    z = 64'hFFF0000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2993863\n");
-    end
-    x = 64'hC710000000001800;
-    y = 64'h666FFE00000001FF;
-    z = 64'hB8E000FFBFFFFFFF;
-    ans = 64'hED8FFE00000031FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2994477\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h8000000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2995091\n");
-    end
-    x = 64'h4011FFFFDFFFFFFF;
-    y = 64'hBFEF9C08BE85F180;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'hBFDC7C4CB8F4F190;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2995705\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hFFE0000000000001;
-    z = 64'h4B9000000007C000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2996319\n");
-    end
-    x = 64'h407000010001FFFF;
-    y = 64'h40059E6C85575EAA;
-    z = 64'h2ED13DD9EC8C1C60;
-    ans = 64'h40859E6DDF40DACC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2996933\n");
-    end
-    x = 64'h39FFFFFFFC00000E;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hF9FFFFFFFC00000D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2997547\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'h47F1FFFFFFFFFDFE;
-    z = 64'h421FFFDDFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2998161\n");
-    end
-    x = 64'h7FDFC02000000000;
-    y = 64'hFFF0000000000000;
-    z = 64'h434367E1A214D062;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2998775\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hBB30000000400020;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"2999389\n");
-    end
-    x = 64'h3FC231C33927C327;
-    y = 64'h024000008000003F;
-    z = 64'h43CFFFFE1FFFFFFF;
-    ans = 64'h43CFFFFE1FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3000003\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3000617\n");
-    end
-    x = 64'hCB0020000000007E;
-    y = 64'hAEEFFFFFFFFFFFBE;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3001231\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h0000000000000000;
-    z = 64'h41C07FFFFFFFFEFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3001845\n");
-    end
-    x = 64'hC36FFFFFFFFE3FFF;
-    y = 64'h43400000003FF7FF;
-    z = 64'h4D21F9255625574B;
-    ans = 64'h4D21F9255625574B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3002459\n");
-    end
-    x = 64'hFD61DD32FB8E3B2C;
-    y = 64'h0000000000000001;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'hBA41DD32FB8E3B2C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3003073\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h3EB6CDE6B789E903;
-    z = 64'hBFB00000001FFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3003687\n");
-    end
-    x = 64'hBFD000000000021F;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'hBCFFFFFBFFFEFFFF;
-    ans = 64'hBCFFFFFBFFFEFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3004301\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h401FFFFFBFC00000;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3004915\n");
-    end
-    x = 64'h42100FFFFFF80000;
-    y = 64'h404000000100003F;
-    z = 64'h6E800003FFFE0000;
-    ans = 64'h6E800003FFFE0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3005529\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h0010000000000001;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3006143\n");
-    end
-    x = 64'hC7EFFFFFFFF7FFFF;
-    y = 64'h1BD000FBFFFFFFFE;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3006757\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hBFF0000000000017;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3007371\n");
-    end
-    x = 64'hC02FFFFFFFBFFEFE;
-    y = 64'hFFE000007FF7FFFF;
-    z = 64'hC800008000000400;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3007985\n");
-    end
-    x = 64'h3DFFFF7FFEFFFFFF;
-    y = 64'h3CA0000000000000;
-    z = 64'h8010000000000000;
-    ans = 64'h3AAFFF7FFEFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3008599\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hBCAFFFFFDFDFFFFF;
-    z = 64'hC00FFFDFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3009213\n");
-    end
-    x = 64'h3FCFFFFFFFFFEEFE;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hBE8FFFFFF01FFFFF;
-    ans = 64'hBE8FFFFFEFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3009827\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h4D70000000040020;
-    z = 64'hC340000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3010441\n");
-    end
-    x = 64'h4804036E90673318;
-    y = 64'hC490001000000010;
-    z = 64'hBFC0000002FFFFFE;
-    ans = 64'hCCA4038293D5C393;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3011055\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h3FD0000000000000;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3011669\n");
-    end
-    x = 64'h37EFFFFFFFF0001F;
-    y = 64'hFFDF23B774D41560;
-    z = 64'h3FE0000000000001;
-    ans = 64'hF7DF23B774C483A2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3012283\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h3FD0000000000001;
-    z = 64'hC02EFFFFFFFDFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3012897\n");
-    end
-    x = 64'h0010000008000100;
-    y = 64'h384000007FFF0000;
-    z = 64'h43D7FFFFFFFFF7FF;
-    ans = 64'h43D7FFFFFFFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3013511\n");
-    end
-    x = 64'h3418CAE9C47A6455;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h8000000000000001;
-    ans = 64'h3408CAE9C47A6453;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3014125\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h41DC1D360A4CE088;
-    z = 64'h47F396D52218D15D;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3014739\n");
-    end
-    x = 64'h406FF800000FFFFF;
-    y = 64'h3FE0000000000001;
-    z = 64'h3FFFF8000000007E;
-    ans = 64'h40603BF000080001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3015353\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h37EFFFFFFFFFFFFF;
-    z = 64'hC010000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3015967\n");
-    end
-    x = 64'h40BFFBFFFFBFFFFF;
-    y = 64'h417DE0C0C0105BC4;
-    z = 64'h3F9FFFFFDFFFFEFF;
-    ans = 64'h424DDD04A7BC9C36;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3016581\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h4340000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3017195\n");
-    end
-    x = 64'h00101FFFFFFBFFFF;
-    y = 64'h0F653D345B988780;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3017809\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h3FF0000000000000;
-    z = 64'hBFC0000080004000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3018423\n");
-    end
-    x = 64'hC3D00000000FBFFF;
-    y = 64'hC03FFFFFFFB7FFFE;
-    z = 64'h37EF000000000000;
-    ans = 64'h441FFFFFFFD77FFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3019037\n");
-    end
-    x = 64'hC18FFFFF8001FFFF;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3019651\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hBFC000001FFFFFE0;
-    z = 64'h37E0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3020265\n");
-    end
-    x = 64'h3FF7FFF7FFFFFFFE;
-    y = 64'h4000000000000000;
-    z = 64'h4340001000000800;
-    ans = 64'h4340001000000801;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3020879\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hBE1202812D66086A;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3021493\n");
-    end
-    x = 64'hC01BDC176961CDDF;
-    y = 64'h41EFFFFFFBFFEFFF;
-    z = 64'h29C00021FFFFFFFF;
-    ans = 64'hC21BDC1765E63D03;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3022107\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3022721\n");
-    end
-    x = 64'h41C000003FFEFFFF;
-    y = 64'hC7FFFFFC003FFFFE;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'hC9CFFFFC803DEFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3023335\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h41E007FFF7FFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3023949\n");
-    end
-    x = 64'h9CDFFFFF8003FFFF;
-    y = 64'hC3CFFFF7FFFFFFFF;
-    z = 64'h41D000011FFFFFFF;
-    ans = 64'h41D000011FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3024563\n");
-    end
-    x = 64'h40BFFFFFFFFF9FFF;
-    y = 64'h4010000000000001;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3025177\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h41F00080FFFFFFFF;
-    z = 64'h3FE00000000043FE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3025791\n");
-    end
-    x = 64'hC0116A3A0E8BD9D8;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h3FD0000007FFFFF0;
-    ans = 64'hC0414A3A0E7BD9D8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3026405\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hD26FFE3FFFFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3027019\n");
-    end
-    x = 64'h402FFFFFFFDFFFFC;
-    y = 64'hBC1A0EF14D39976E;
-    z = 64'hC0776D17463EB959;
-    ans = 64'hC0776D17463EB959;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3027633\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h4340000000000001;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3028247\n");
-    end
-    x = 64'hC800003FFFFFF7FF;
-    y = 64'hBFBFFFDFF7FFFFFE;
-    z = 64'h3CA0000000000000;
-    ans = 64'h47D0002FFBBFE7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3028861\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h41DE8439E1A9A3DA;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3029475\n");
-    end
-    x = 64'hFFDF39CFA8A03BE2;
-    y = 64'hC3D000000040003E;
-    z = 64'h400C000000000800;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3030089\n");
-    end
-    x = 64'h37E003EFFFFFFFFF;
-    y = 64'h7FE0000000000000;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3030703\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hC04FFE000007FFFF;
-    z = 64'hBD8EFFFFFFFFFFDF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3031317\n");
-    end
-    x = 64'h7FE173412B78E0FE;
-    y = 64'h7FE0000000000001;
-    z = 64'h43AFFFFFF7FFF000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3031931\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h4316F79517C28E75;
-    z = 64'hBFF0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3032545\n");
-    end
-    x = 64'hC02200000000003F;
-    y = 64'h4010007FFFFFFFFF;
-    z = 64'hB8100001FFFFFF00;
-    ans = 64'hC04200900000003E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3033159\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h7FF0000000000000;
-    z = 64'h4000000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3033773\n");
-    end
-    x = 64'hC5CC79F66E8517AD;
-    y = 64'h3DAFBFFFFFFFFFDE;
-    z = 64'h0010000000000001;
-    ans = 64'hC38C410281A80D5F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3034387\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h7FF0000000000001;
-    z = 64'h7FD0D5BD4FCDC113;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3035001\n");
-    end
-    x = 64'hAC400001000FFFFE;
-    y = 64'hC00FFFFFE0003FFE;
-    z = 64'h3FDFFEFFFFFFFFFD;
-    ans = 64'h3FDFFEFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3035615\n");
-    end
-    x = 64'h40BFFFFF0000003F;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h4340000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3036229\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hFFDFFFFFEFFFFFFF;
-    z = 64'hBC157D122DBD3C91;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3036843\n");
-    end
-    x = 64'h409FFC0000000002;
-    y = 64'h8000000000000000;
-    z = 64'hB8020D0B3462BA3F;
-    ans = 64'hB8020D0B3462BA3F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3037457\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h40B0004003FFFFFF;
-    z = 64'hBFE0000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3038071\n");
-    end
-    x = 64'h4030FBFFFFFFFFFF;
-    y = 64'h40A8000000000010;
-    z = 64'h6560001FFC000000;
-    ans = 64'h6560001FFC000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3038685\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h3FF0000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3039299\n");
-    end
-    x = 64'hBFC0000000000002;
-    y = 64'h400FFFF80000000F;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hBFDFFFF800000013;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3039913\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h8010000000000000;
-    z = 64'hBF497D946A140E35;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3040527\n");
-    end
-    x = 64'h3FCFFFFFC8000000;
-    y = 64'h40429DE6F85FE585;
-    z = 64'hBD33E8B29443F848;
-    ans = 64'h40229DE6D7CB912B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3041141\n");
-    end
-    x = 64'hC0004000000003FF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3041755\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h1ED0088000000000;
-    z = 64'h43C0004000000800;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3042369\n");
-    end
-    x = 64'h801000FFDFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hBCAFFFFFFFFFBEFE;
-    ans = 64'hBCAFFFFFFFFFBEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3042983\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hC5AFFEFFFFFEFFFF;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3043597\n");
-    end
-    x = 64'h43CC000000008000;
-    y = 64'hBF9FEFFFFFFFEFFE;
-    z = 64'h5560000800000FFE;
-    ans = 64'h5560000800000FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3044211\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3044825\n");
-    end
-    x = 64'h801FE00000000FFF;
-    y = 64'hFF0003FDFFFFFFFF;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3045439\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hC3EFFFFFFFF0003E;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3046053\n");
-    end
-    x = 64'h90B67083F2F3B2BE;
-    y = 64'h8021AA0E74B7BE9A;
-    z = 64'h344A4B5F400DAE2F;
-    ans = 64'h344A4B5F400DAE2F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3046667\n");
-    end
-    x = 64'h434FFFFF8000003E;
-    y = 64'hBFD0000000000001;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'hC32FFFFF80000038;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3047281\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h38200000040FFFFF;
-    z = 64'h45BEFFFFEFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3047895\n");
-    end
-    x = 64'hC3D000000001FFDE;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hC80FFFFFFFFDF800;
-    ans = 64'hC80FFFFFFFFDF800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3048509\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h3801FFFFF7FFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3049123\n");
-    end
-    x = 64'hC0B000000000100E;
-    y = 64'h43FFFFFBFFFFEFFF;
-    z = 64'h40200000000FFEFF;
-    ans = 64'hC4BFFFFC0000101B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3049737\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hBFE0000000000001;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3050351\n");
-    end
-    x = 64'hC47F9B896EE345AF;
-    y = 64'hB7FE6C64EA47F3E0;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3050965\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h16FFFC03FFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3051579\n");
-    end
-    x = 64'h41C0000082000000;
-    y = 64'h41E01FFFFFFBFFFF;
-    z = 64'hC05FFFFFFFF00001;
-    ans = 64'h43B0200082FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3052193\n");
-    end
-    x = 64'h3FFFF800003FFFFE;
-    y = 64'hBFF0000000000000;
-    z = 64'h4000000000000000;
-    ans = 64'h3F5FFFFF00000800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3052807\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h381FFFF800FFFFFE;
-    z = 64'hBFE7942C107C146D;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3053421\n");
-    end
-    x = 64'h0000EC4C3D4CE00C;
-    y = 64'hBFF0000000000001;
-    z = 64'hC7F0020000000003;
-    ans = 64'hC7F0020000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3054035\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hFFEFFFFFBFFFDFFF;
-    z = 64'hBCA0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3054649\n");
-    end
-    x = 64'hC0CDFFFFEFFFFFFE;
-    y = 64'h3EBFFFFFFE800000;
-    z = 64'h400000000BFFFFFF;
-    ans = 64'h3FFF880018459FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3055263\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hC000000000000000;
-    z = 64'h3FD0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3055877\n");
-    end
-    x = 64'hB7EFBFEFFFFFFFFF;
-    y = 64'hC01FFBFFFFF7FFFF;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3056491\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hC000000000000001;
-    z = 64'h3F3FFFFFFFFBFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3057105\n");
-    end
-    x = 64'hBC1A7DA73DBA86FA;
-    y = 64'hBFB0000002FFFFFF;
-    z = 64'h384EFFFFFFFFFFFE;
-    ans = 64'h3BDA7DA742B21654;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3057719\n");
-    end
-    x = 64'hC07D6677D809944E;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h3FF0000000000001;
-    ans = 64'h409D6A77D809944C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3058333\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hBFBFFFFFF8001FFF;
-    z = 64'h3B1FC0000000000F;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3058947\n");
-    end
-    x = 64'h3FFFFFFFFFFFC00E;
-    y = 64'hC010000000000000;
-    z = 64'hC1C0000000403FFE;
-    ans = 64'hC1C0000004403FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3059561\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h4000000200001000;
-    z = 64'h8010000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3060175\n");
-    end
-    x = 64'hD50000000000FFFF;
-    y = 64'h41D007FFFFBFFFFF;
-    z = 64'hFFF0000000800400;
-    ans = 64'hFFF8000000800400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3060789\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h3CA0000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3061403\n");
-    end
-    x = 64'hC026021B608EA2C6;
-    y = 64'hBFE00000001FFFFD;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3062017\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hC340000000000000;
-    z = 64'h37EFFEFBFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3062631\n");
-    end
-    x = 64'h4E82000000000010;
-    y = 64'hC1D2D177358C80A2;
-    z = 64'hC03FFFFFFFBFFC00;
-    ans = 64'hD0652BA61C3E10C9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3063245\n");
-    end
-    x = 64'hC346D9C6FAF76368;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h46A6D9C6FAF76367;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3063859\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hC3CFFFFFF800000F;
-    z = 64'h7FFFFFEFFFFFFFBF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3064473\n");
-    end
-    x = 64'hB54BFFE5FD756E11;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h674E709D89CD1045;
-    ans = 64'h674E709D89CD1045;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3065087\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hB7FFFFFFFBFFFFF7;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3065701\n");
-    end
-    x = 64'h3FC00003FC000000;
-    y = 64'h41CFFFFFFF0007FE;
-    z = 64'h8010007FFFFBFFFF;
-    ans = 64'h41A00003FB8003DF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3066315\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3066929\n");
-    end
-    x = 64'h28157F6040613C66;
-    y = 64'h705800FFFFFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'h588020342B4AF055;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3067543\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h41C01FFFFBFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3068157\n");
-    end
-    x = 64'hBFFFFFFFFE000FFE;
-    y = 64'h41E1327FFABA4463;
-    z = 64'hB7FFFFFFFFC00000;
-    ans = 64'hC1F1327FF9A724FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3068771\n");
-    end
-    x = 64'hC05FFFFF80000000;
-    y = 64'hFFF0000000000001;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3069385\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h3FC4E9D3D378B53D;
-    z = 64'h3FA000200000000F;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3069999\n");
-    end
-    x = 64'hC06FFFF7FFFFFFFB;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hC030001FFFFFFFFD;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3070613\n");
-    end
-    x = 64'h7FFFFFFFFFFFFFFE;
-    y = 64'h403F5FC3BCD9FA44;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3071227\n");
-    end
-    x = 64'hC02E18F44A3E03BD;
-    y = 64'h3FA00000FFFFFFF8;
-    z = 64'hFFF00000000FFFFF;
-    ans = 64'hFFF80000000FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3071841\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h0000000000000001;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h000FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3072455\n");
-    end
-    x = 64'hBFEA884E50247B88;
-    y = 64'hC39A5B2CF6AC3C47;
-    z = 64'hC010000000000000;
-    ans = 64'h4395DA5887C3E2F7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3073069\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h43D02FFFFFFFFFFF;
-    ans = 64'h43D02FFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3073683\n");
-    end
-    x = 64'hC1F3FBFFFFFFFFFF;
-    y = 64'h3CA00000000017FF;
-    z = 64'hDE3BFDFFFFFFFFFF;
-    ans = 64'hDE3BFDFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3074297\n");
-    end
-    x = 64'h3FCFFFFFEFFFFFBF;
-    y = 64'h0010000000000000;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3074911\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hC1F457645C6077D2;
-    z = 64'h41CE000007FFFFFF;
-    ans = 64'h41CE000007FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3075525\n");
-    end
-    x = 64'hED901FFFFFFFFFF7;
-    y = 64'h0010000000000001;
-    z = 64'h43C0003FFFFFF7FF;
-    ans = 64'h43C0003FFFFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3076139\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hC030000040400000;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3076753\n");
-    end
-    x = 64'h3FC021FFFFFFFFFE;
-    y = 64'hBCAF7FFFEFFFFFFE;
-    z = 64'hC341F7FFFFFFFFFE;
-    ans = 64'hC341F7FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3077367\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h3CA0000000000000;
-    z = 64'h0000000000000000;
-    ans = 64'h0000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3077981\n");
-    end
-    x = 64'h47EFFFFFFF804000;
-    y = 64'h802FFFFFFC100000;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3078595\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h3CA0000000000001;
-    z = 64'hC032000000000FFF;
-    ans = 64'hC032000000000FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3079209\n");
-    end
-    x = 64'hFFF0100000007FFF;
-    y = 64'hBE50007F80000000;
-    z = 64'hC3450907904A895D;
-    ans = 64'hFFF8100000007FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3079823\n");
-    end
-    x = 64'h7FEFC3FFFFFFFFFF;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h3CA0000000000001;
-    ans = 64'h7CAFC3FFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3080437\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hC3FBC0311875347E;
-    z = 64'h404740F81BE91948;
-    ans = 64'h404740F81BE91948;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3081051\n");
-    end
-    x = 64'h40F0003FC0000000;
-    y = 64'h3FD0000000000000;
-    z = 64'h41E9224C4FC48A71;
-    ans = 64'h41E922544FE46A71;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3081665\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h7FF001FFFFFF7FFF;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FF801FFFFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3082279\n");
-    end
-    x = 64'h3FC0020007FFFFFE;
-    y = 64'h3FFD07336C3C07A2;
-    z = 64'hAE1A599530074107;
-    ans = 64'h3FCD0AD4612D28D5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3082893\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3083507\n");
-    end
-    x = 64'h001BB71BCC644518;
-    y = 64'h3CCA1657CF69F990;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3084121\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h3FE0000000000000;
-    z = 64'hFFFB22B4429E5973;
-    ans = 64'hFFFB22B4429E5973;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3084735\n");
-    end
-    x = 64'hC6503FFFFFFFFFEF;
-    y = 64'hC80FFFFF803FFFFE;
-    z = 64'h4800100002000000;
-    ans = 64'h4E703FFFBF207FEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3085349\n");
-    end
-    x = 64'h404FFFFFFF802000;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h404FFFFFFF801FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3085963\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h43DFFE0000000002;
-    z = 64'h3FCFFFC00001FFFF;
-    ans = 64'h3FCFFFC00001FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3086577\n");
-    end
-    x = 64'h37EFF003FFFFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h455000003FFFEFFF;
-    ans = 64'h455000003FFFEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3087191\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hC1D4D2909DF566D4;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3087805\n");
-    end
-    x = 64'hCC70E9EB1B349793;
-    y = 64'h405FC00000000020;
-    z = 64'hC26100003FFFFFFE;
-    ans = 64'hCCE0C81744FE2E75;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3088419\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h3FF0000000000001;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3089033\n");
-    end
-    x = 64'hECD000FDFFFFFFFF;
-    y = 64'h40800000000003DE;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hED6000FE000003DD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3089647\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h22DFFFFFFEFFF7FF;
-    ans = 64'h22DFFFFFFEFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3090261\n");
-    end
-    x = 64'hC000010003FFFFFF;
-    y = 64'h43D0080000000800;
-    z = 64'h5B3C1ACD83585189;
-    ans = 64'h5B3C1ACD83585189;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3090875\n");
-    end
-    x = 64'hC7EFFBFFFFFFFEFF;
-    y = 64'h4000000000000001;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'hC7FFFBFFFFFFFF01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3091489\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h3F2888DBBA853F4F;
-    z = 64'h43BFFFFFFFC00008;
-    ans = 64'h43BFFFFFFFC00008;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3092103\n");
-    end
-    x = 64'h3FC000001FFBFFFF;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h3808347E56DF1CFB;
-    ans = 64'h3FE000001FFBFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3092717\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h7FFFFFFFFFFF77FF;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFF77FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3093331\n");
-    end
-    x = 64'hB19FFFFFFFFFFBFE;
-    y = 64'hC01FFFFDFFFDFFFF;
-    z = 64'h24DFE0000000003F;
-    ans = 64'h31CFFFFDFFFDFBFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3093945\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h4010000000000000;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3094559\n");
-    end
-    x = 64'hBFC08000007FFFFF;
-    y = 64'hC01FFF7FFFFEFFFF;
-    z = 64'hBFE0000000000000;
-    ans = 64'h3FE0FF7C00FEF3FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3095173\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h41FFFFFFFFFFF7EF;
-    ans = 64'h41FFFFFFFFFFF7EF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3095787\n");
-    end
-    x = 64'h403DB03B87843F76;
-    y = 64'hBF800000000FF7FF;
-    z = 64'hC1EFFFFFFFFFFFFF;
-    ans = 64'hC1F000000003B607;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3096401\n");
-    end
-    x = 64'h43F0007F7FFFFFFE;
-    y = 64'h4340000000000000;
-    z = 64'h0000000000000000;
-    ans = 64'h4740007F7FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3097015\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h45500000BFFFFFFE;
-    z = 64'h4017E8D64105A119;
-    ans = 64'h4017E8D64105A119;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3097629\n");
-    end
-    x = 64'h401FFFFFFDFFFFFF;
-    y = 64'h4340000000000001;
-    z = 64'hBFC01EFFFFFFFFFE;
-    ans = 64'h436FFFFFFE000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3098243\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h3FDFFC0001FFFFFF;
-    z = 64'h4010000000000000;
-    ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3098857\n");
-    end
-    x = 64'hC1CFF7FFFFEFFFFF;
-    y = 64'hBDE0005FFFFFFFFF;
-    z = 64'hC7F0000000803FFF;
-    ans = 64'hC7F0000000803FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3099471\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3100085\n");
-    end
-    x = 64'hC030A7CF373B62D5;
-    y = 64'hBF4D228689037BA6;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFCE1ABE7C78711C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3100699\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h7FE0000000000001;
-    z = 64'hCC7001FDFFFFFFFF;
-    ans = 64'hCC7001FDFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3101313\n");
-    end
-    x = 64'hC1C0FFFFFF7FFFFF;
-    y = 64'h40070F82E6044AF0;
-    z = 64'h3E5FFC000000001F;
-    ans = 64'hC1D8807B13AC1386;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3101927\n");
-    end
-    x = 64'h3FBFFFDFF7FFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3102541\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hC03000003FFE0000;
-    z = 64'h3FF00000000007FF;
-    ans = 64'h3FF00000000007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3103155\n");
-    end
-    x = 64'hC80FFFFFFFDFFFF6;
-    y = 64'h7FF0000000000000;
-    z = 64'h802ACE332F4C4763;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3103769\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hB7E0000000007FFB;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3104383\n");
-    end
-    x = 64'hC80DB237A7B2ECFA;
-    y = 64'h43CF7FFF00000000;
-    z = 64'hC0942C91CBC6742F;
-    ans = 64'hCBED3B6DDB826409;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3104997\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'hC010000000000001;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3105611\n");
-    end
-    x = 64'hBD800000FFEFFFFF;
-    y = 64'hBCA000000000047F;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3106225\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h8000000000000000;
-    z = 64'h3FF00000007FF000;
-    ans = 64'h3FF00000007FF000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3106839\n");
-    end
-    x = 64'hC03D0F79F2E2110C;
-    y = 64'hC03000FFFFFFFFEF;
-    z = 64'h001E8FC2A817327E;
-    ans = 64'h407D114AEA813F0E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3107453\n");
-    end
-    x = 64'h4010000003FFC000;
-    y = 64'h8000000000000001;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3108067\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hBFAC4EA8DFBA2E0F;
-    z = 64'h2EAFFBE000000000;
-    ans = 64'h2EAFFBE000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3108681\n");
-    end
-    x = 64'hC1CFFDFFFC000000;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h3FBFFFFFFFDFFFBF;
-    ans = 64'h3FBFFFFFFFDFFFBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3109295\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hEF50DFFFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h3FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3109909\n");
-    end
-    x = 64'hBFEFFF7FFC000000;
-    y = 64'h802C0000000007FF;
-    z = 64'hC34020C551346F33;
-    ans = 64'hC34020C551346F33;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3110523\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h8010000000000001;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3111137\n");
-    end
-    x = 64'h4016D2AF65546489;
-    y = 64'h802FFFF00003FFFE;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h8058D2A3FBFF8C33;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3111751\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hBF5000001FFFFF7F;
-    ans = 64'hBF5000001FFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3112365\n");
-    end
-    x = 64'hBC494CF44BE411E4;
-    y = 64'h40D0800FFFFFFFFF;
-    z = 64'h3F2FF0000003FFFE;
-    ans = 64'h3F2FEFFFFFE9E889;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3112979\n");
-    end
-    x = 64'hC0B0400000010000;
-    y = 64'hBCA0000000000000;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3113593\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h43CFFFFFF803FFFF;
-    z = 64'hFFFFDFFDFFFFFFFE;
-    ans = 64'hFFFFDFFDFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3114207\n");
-    end
-    x = 64'h43400047FFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'hBFD75FA2A3A89086;
-    ans = 64'hC002EC3C5475120F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3114821\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hB4CFFFFFFFFBFF00;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h3FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3115435\n");
-    end
-    x = 64'hD64FFFFFF0080000;
-    y = 64'hD1DDB24D08FC815F;
-    z = 64'hC660000001000000;
-    ans = 64'h683DB24CFA2AC76E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3116049\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hBFD0000000000000;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3116663\n");
-    end
-    x = 64'h000FFF000000000F;
-    y = 64'h3FF00800001FFFFF;
-    z = 64'h8010000000000000;
-    ans = 64'h000006FF801FFE0E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3117277\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h2BAFFFFE00000400;
-    ans = 64'h2BAFFFFE00000400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3117891\n");
-    end
-    x = 64'h9A73CCE1CA1D11E1;
-    y = 64'h47EFFFFF07FFFFFF;
-    z = 64'h380E615AE8E06D92;
-    ans = 64'h380E615AE8E06D92;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3118505\n");
-    end
-    x = 64'h43E000FFFFFFDFFF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'hC340000000000000;
-    ans = 64'hC3D008FFFFFFDFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3119119\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hB7E4D7D8D41529FE;
-    z = 64'hC7F10000001FFFFF;
-    ans = 64'hC7F10000001FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3119733\n");
-    end
-    x = 64'h480FFFC000000004;
-    y = 64'hBFE0000000000001;
-    z = 64'hFFDFE0000003FFFF;
-    ans = 64'hFFDFE0000003FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3120347\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h593FF0000FFFFFFF;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3120961\n");
-    end
-    x = 64'hC06B9417C0033A6E;
-    y = 64'h7FD0200000002000;
-    z = 64'hC1C00000004001FF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3121575\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3122189\n");
-    end
-    x = 64'h4760000FF7FFFFFF;
-    y = 64'hC020001000001FFF;
-    z = 64'h8000000000000001;
-    ans = 64'hC790001FF81017FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3122803\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hBFF0000000000001;
-    z = 64'h41EE7FFFFFFFFFFF;
-    ans = 64'h41EE7FFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3123417\n");
-    end
-    x = 64'hB7F000000003FFFC;
-    y = 64'hC3EBFFFFC0000000;
-    z = 64'h4340020000007FFF;
-    ans = 64'h4340020000007FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3124031\n");
-    end
-    x = 64'h00156990261BEC37;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3124645\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hB7FFFFFFFFFF03FF;
-    z = 64'hEEDF000000000200;
-    ans = 64'hEEDF000000000200;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3125259\n");
-    end
-    x = 64'h8021FFFFFFFF7FFF;
-    y = 64'hC000000000000000;
-    z = 64'h41DF7FFFFFDFFFFF;
-    ans = 64'h41DF7FFFFFDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3125873\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h4013FFFFFFFFFFDF;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3126487\n");
-    end
-    x = 64'hC02FFFFFBFFFFEFF;
-    y = 64'h3C0EBC9683E33424;
-    z = 64'h2BCFFFFFF0000000;
-    ans = 64'hBC4EBC96466A0625;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3127101\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3127715\n");
-    end
-    x = 64'hC0200800000003FF;
-    y = 64'hC05BFA48DAC0DE8C;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3128329\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hC010000000000000;
-    z = 64'hBFCFE49E2BE245B9;
-    ans = 64'hBFCFE49E2BE245B9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3128943\n");
-    end
-    x = 64'h41C000FFFFFFFEFF;
-    y = 64'h3FBCFA3A6B7AD55E;
-    z = 64'h3FDFFFFFFFFFE020;
-    ans = 64'h418CFC0A13218B3A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3129557\n");
-    end
-    x = 64'h42B0000000800002;
-    y = 64'hC010000000000001;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC2D0000000800103;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3130171\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h2CFFFBFFFFFFFFF6;
-    z = 64'h3FE07FFFFFFBFFFE;
-    ans = 64'h3FE07FFFFFFBFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3130785\n");
-    end
-    x = 64'h802000000001F7FE;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h40307FFFFFFFFFFD;
-    ans = 64'h40307FFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3131399\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h47AF7DFFFFFFFFFF;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3132013\n");
-    end
-    x = 64'hBFB00000002FFFFE;
-    y = 64'h449FFFFFFFFEF7FE;
-    z = 64'hC07000000FF7FFFE;
-    ans = 64'hC4600000002F7BFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3132627\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hC340000000000001;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3133241\n");
-    end
-    x = 64'hC3CFFFFFFE00000F;
-    y = 64'h401FA0393503D82D;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3133855\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h3E9FFC0000000400;
-    ans = 64'h3E9FFC0000000400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3134469\n");
-    end
-    x = 64'h41CFFFF3FFFFFFFE;
-    y = 64'h37F19D07D7E0590A;
-    z = 64'hBCAFFFFFFC00FFFF;
-    ans = 64'hBCAFFFFFFC00FF72;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3135083\n");
-    end
-    x = 64'h3F6FFFFFFF003FFE;
-    y = 64'hFFE0000000000000;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hFF5FFFFFFF003FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3135697\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'h43400001FFFFF7FE;
-    z = 64'h43E002FFFFFFFFFF;
-    ans = 64'h43E002FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3136311\n");
-    end
-    x = 64'hC1F6144314164BCD;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h40F003FFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3136925\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hC019164BC4066991;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h001FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3137539\n");
-    end
-    x = 64'hB8000000010003FF;
-    y = 64'hC0F46B4BFE151F0B;
-    z = 64'h38000000001BFFFF;
-    ans = 64'h39046B5BFF5BD900;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3138153\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hFFF0000000000000;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hFFF8000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3138767\n");
-    end
-    x = 64'hC2900000001FFEFE;
-    y = 64'hC065A4DA1815F209;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3139381\n");
-    end
-    x = 64'h8000000000000000;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hA90FFFF000000080;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3139995\n");
-    end
-    x = 64'h434FFFFFFDFFFFF7;
-    y = 64'h43DFFFFC00001FFF;
-    z = 64'hBAB00003FFDFFFFF;
-    ans = 64'h473FFFFBFE002036;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3140609\n");
-    end
-    x = 64'hCFFFFFFFFFFFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hBFF0000000000000;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3141223\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h3F90080000000000;
-    z = 64'hC1F000001FFFFFE0;
-    ans = 64'hC1F000001FFFFFE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3141837\n");
-    end
-    x = 64'hC7E0000040000FFE;
-    y = 64'h0000000000000001;
-    z = 64'h37E0000000000011;
-    ans = 64'h37E0000000000011;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3142451\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h400EFFFFFF000000;
-    z = 64'h0010000000000000;
-    ans = 64'h000FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3143065\n");
-    end
-    x = 64'h43EDDFB09753FFA6;
-    y = 64'h37AFFFF003FFFFFF;
-    z = 64'h3FF1C45D282E7E53;
-    ans = 64'h3FF1C45D282E7E53;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3143679\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'hBCA0000000000000;
-    ans = 64'hBCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3144293\n");
-    end
-    x = 64'hBFD00003FFFFFFEF;
-    y = 64'hBFDACEDC26695437;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3144907\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h0010000000000001;
-    z = 64'hC1C1DFFFFFFFFFFF;
-    ans = 64'hC1C1DFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3145521\n");
-    end
-    x = 64'h4040000000000801;
-    y = 64'hC7800007FFFFFFEF;
-    z = 64'hC04FFFFFFFFBFFEF;
-    ans = 64'hC7D00008000007F0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3146135\n");
-    end
-    x = 64'hC35FFFFD7FFFFFFE;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3146749\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h3FDFFFFE007FFFFF;
-    z = 64'h3940C6BA3B0B3184;
-    ans = 64'h3940C6BA3B0B3184;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3147363\n");
-    end
-    x = 64'h7FFFF00000000000;
-    y = 64'h3CA0000000000000;
-    z = 64'hBBA00000000EFFFF;
-    ans = 64'h7FFFF00000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3147977\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h40211275FFE5EE3C;
-    z = 64'h0000000000000001;
-    ans = 64'h8000000000000008;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3148591\n");
-    end
-    x = 64'hC0C00000013FFFFE;
-    y = 64'h4067902331AAF6C5;
-    z = 64'h380FFFFFFFE00000;
-    ans = 64'hC137902333823982;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3149205\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h8010000000000001;
-    ans = 64'h8010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3149819\n");
-    end
-    x = 64'hC050000000010000;
-    y = 64'hBF1003FFFFF7FFFE;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h402002007FFFFF20;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3150433\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h3FD0000000000000;
-    z = 64'h3FDFFFFFFBF80000;
-    ans = 64'h3FDFFFFFFBF80000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3151047\n");
-    end
-    x = 64'h41A2FFFFFFFFFFFF;
-    y = 64'hC01F4C181CF9031A;
-    z = 64'h59EAEF43B21B025D;
-    ans = 64'h59EAEF43B21B025D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3151661\n");
-    end
-    x = 64'h2F4FFFFFFFBFFF7F;
-    y = 64'h3FD0000000000001;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3152275\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hC1C01FFFFFFFFEFE;
-    z = 64'h03100007FE000000;
-    ans = 64'h03100007FE000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3152889\n");
-    end
-    x = 64'h41D0000100000800;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h37000000000FFEFF;
-    ans = 64'h41C00001000007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3153503\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hBFD00000003FFFFF;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3154117\n");
-    end
-    x = 64'h3FCFFFFDFFFFFFFE;
-    y = 64'hB5A72C97AC0E810C;
-    z = 64'hC3D000000040001F;
-    ans = 64'hC3D000000040001F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3154731\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h3FE0000000000001;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h8010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3155345\n");
-    end
-    x = 64'h3E1E236829225737;
-    y = 64'hB7E405088A99DC41;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3155959\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h3CAFFFFC003FFFFF;
-    ans = 64'h3CAFFFFC003FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3156573\n");
-    end
-    x = 64'h9EAF803FFFFFFFFF;
-    y = 64'h985FFFFC000007FF;
-    z = 64'hBFBFFE007FFFFFFE;
-    ans = 64'hBFBFFE007FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3157187\n");
-    end
-    x = 64'h3FDFFFFFE03FFFFF;
-    y = 64'h3FF0000000000000;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFE03FFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3157801\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h3817CB84DBC4B68E;
-    z = 64'hC03F153C7B568390;
-    ans = 64'hC03F153C7B568390;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3158415\n");
-    end
-    x = 64'h41CFFFFFFFFFDFDE;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h3FBFFDFFFF000000;
-    ans = 64'h41E000000003EFAE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3159029\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hC03FFFFFFFFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3159643\n");
-    end
-    x = 64'h41CA0E88599F6184;
-    y = 64'hC34FFFFF801FFFFE;
-    z = 64'h43D000400FFFFFFF;
-    ans = 64'hC52A0E87717D4E24;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3160257\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h4000000000000000;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3160871\n");
-    end
-    x = 64'h41CFFFFFFFFFEFF0;
-    y = 64'hC02FFBFFFFFFF7FF;
-    z = 64'h4000000000000000;
-    ans = 64'hC20FFBFFFFEFE7F1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3161485\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h3FD0800002000000;
-    ans = 64'h3FD0800002000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3162099\n");
-    end
-    x = 64'hC07000000000005E;
-    y = 64'h3F20000000103FFF;
-    z = 64'hC1D07FFF7FFFFFFF;
-    ans = 64'hC1D07FFF8001FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3162713\n");
-    end
-    x = 64'hBFC01FFFFFFFFE00;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hBCA0000000000000;
-    ans = 64'hBFE01FFFFFFFFE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3163327\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hBEE0000807FFFFFE;
-    z = 64'hD47000001E000000;
-    ans = 64'hD47000001E000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3163941\n");
-    end
-    x = 64'hB81DAD3FB1C8BFCB;
-    y = 64'h4010000000000001;
-    z = 64'hC03FFE0FFFFFFFFE;
-    ans = 64'hC03FFE0FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3164555\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hC15FFBFFFFFFFBFF;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3165169\n");
-    end
-    x = 64'h400C05A976082539;
-    y = 64'h3B20008007FFFFFF;
-    z = 64'h4000200000200000;
-    ans = 64'h4000200000200000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3165783\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3166397\n");
-    end
-    x = 64'h43EF3C4FB6317308;
-    y = 64'h401FA877217B4DCA;
-    z = 64'h3FF0000000000001;
-    ans = 64'h441EE6DE23F36688;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3167011\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h4340000000000001;
-    z = 64'h43FFFFFFFFFFFDF7;
-    ans = 64'h43FFFFFFFFFFFDF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3167625\n");
-    end
-    x = 64'h381B8A7CEA43CD38;
-    y = 64'hBCA00000000000FE;
-    z = 64'hBFCFF7FFFFFFFBFF;
-    ans = 64'hBFCFF7FFFFFFFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3168239\n");
-    end
-    x = 64'h3FC0003000000000;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h8010000000000001;
-    ans = 64'h4320002FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3168853\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hC1C8000007FFFFFE;
-    z = 64'hC3CC26562E83F4EA;
-    ans = 64'hC3CC26562E83F4EA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3169467\n");
-    end
-    x = 64'hC0039AA7F4BDCC1A;
-    y = 64'h7FE0000000000000;
-    z = 64'h2EFFFFFFFF0003FF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3170081\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h7FEF848CC01517B4;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3170695\n");
-    end
-    x = 64'h43CFFC0000000020;
-    y = 64'h4EF11317FB120971;
-    z = 64'h32A0000003BFFFFF;
-    ans = 64'h52D110F59812A741;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3171309\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3171923\n");
-    end
-    x = 64'hBE3FFFC1FFFFFFFE;
-    y = 64'h1500000000080008;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3172537\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h410FFFFFFC007FFE;
-    ans = 64'h410FFFFFFC007FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3173151\n");
-    end
-    x = 64'h7FFE07FFFFFFFFFF;
-    y = 64'h40FFFF3FFFFFFFFE;
-    z = 64'h47700F8000000000;
-    ans = 64'h7FFE07FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3173765\n");
-    end
-    x = 64'hBFDFFFFFBFFFF7FF;
-    y = 64'h7FF0000000000001;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3174379\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hA2600000080000FF;
-    z = 64'hBCEB98ACD7FD8CA0;
-    ans = 64'hBCEB98ACD7FD8CA0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3174993\n");
-    end
-    x = 64'hFFD0000000380000;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h3F61000000100000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3175607\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hBFE00007FFFEFFFF;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3176221\n");
-    end
-    x = 64'h801FFFF000002000;
-    y = 64'h3E4000007FBFFFFF;
-    z = 64'hFFEFFFBFBFFFFFFE;
-    ans = 64'hFFEFFFBFBFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3176835\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h8000000000000001;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3177449\n");
-    end
-    x = 64'hCA1FFFFFBFEFFFFF;
-    y = 64'h40104000000000FE;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'hCA403FFFDF77E0FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3178063\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h50BFFFFF80000007;
-    ans = 64'h50BFFFFF80000007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3178677\n");
-    end
-    x = 64'hC1F0010000001FFF;
-    y = 64'h4682F7C4BE71CF6A;
-    z = 64'h801FBC2C44B340E6;
-    ans = 64'hC882F8F43ABDDC75;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3179291\n");
-    end
-    x = 64'h3FF000000080007F;
-    y = 64'h8010000000000000;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3179905\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h3F810000003FFFFE;
-    z = 64'h3FF7FFFFFFFFFFEF;
-    ans = 64'h3FF7FFFFFFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3180519\n");
-    end
-    x = 64'hBFB0009FFFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h47E14C1A2DD3B4B1;
-    ans = 64'h47E14C1A2DD3B4B1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3181133\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hB7F000000000003E;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3181747\n");
-    end
-    x = 64'hC9AFFFFFFEEFFFFF;
-    y = 64'hC030000001FFFFF6;
-    z = 64'h400000400000007F;
-    ans = 64'h49F000000177FFF5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3182361\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hBCA0000000000000;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3182975\n");
-    end
-    x = 64'h37E0010400000000;
-    y = 64'hB60E000040000000;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3183589\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hBCA0000000000001;
-    z = 64'h3FFEFFFFFFFFFFFD;
-    ans = 64'h3FFEFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3184203\n");
-    end
-    x = 64'hC051984EB254C405;
-    y = 64'h380FFFFFFFFFFFBD;
-    z = 64'hBFDFFFFEFFFE0000;
-    ans = 64'hBFDFFFFEFFFE0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3184817\n");
-    end
-    x = 64'hDFF000000001FFC0;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3185431\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h403FFFFAFFFFFFFF;
-    z = 64'h3FBFFFFF0000FFFE;
-    ans = 64'h3FBFFFFF0000FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3186045\n");
-    end
-    x = 64'h3FD00000040000FF;
-    y = 64'hBFD0000000000001;
-    z = 64'h3B9FFFFEFFFFFFFD;
-    ans = 64'hBFB0000004000100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3186659\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h585F840000000000;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3187273\n");
-    end
-    x = 64'h3FE010003FFFFFFF;
-    y = 64'h3FDCF4E15823EAC4;
-    z = 64'h40D002000000001F;
-    ans = 64'h40D0020E88EB56C7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3187887\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h4010000000000000;
-    ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3188501\n");
-    end
-    x = 64'h3FFFFFFFFFC02000;
-    y = 64'h3FEE000020000000;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3FFE00001FC41E00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3189115\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hBFE0000000000000;
-    z = 64'hCF2FFFFF00080000;
-    ans = 64'hCF2FFFFF00080000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3189729\n");
-    end
-    x = 64'hBFCE0B425BCBFB74;
-    y = 64'hC060000000047FFF;
-    z = 64'h43D0008000007FFF;
-    ans = 64'h43D0008000007FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3190343\n");
-    end
-    x = 64'h480FC00000000006;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3190957\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h47F1710E4E562E96;
-    z = 64'hBD4FFFFFF7FFDFFF;
-    ans = 64'hBD4FFFFFF7FFDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3191571\n");
-    end
-    x = 64'h986A47CFEF9354B1;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hC1FDFFFFFFFFDFFF;
-    ans = 64'hC1FDFFFFFFFFDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3192185\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h7FFC6AF03F2EE520;
-    z = 64'hBFF0000000000001;
-    ans = 64'h7FFC6AF03F2EE520;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3192799\n");
-    end
-    x = 64'h41D0FFFFFFF00000;
-    y = 64'hC670400000000010;
-    z = 64'h802A369C60C3660A;
-    ans = 64'hC85143FFFFEFC011;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3193413\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3194027\n");
-    end
-    x = 64'hA89FF00000002000;
-    y = 64'hC3CF7FFFEFFFFFFF;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h2C7F703FF0081F7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3194641\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h002E000000100000;
-    ans = 64'h002E000000100001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3195255\n");
-    end
-    x = 64'hFBACD419571A8A67;
-    y = 64'hBFB000000007FFF6;
-    z = 64'hCCFFFFFFFFEBFFFF;
-    ans = 64'h7B6CD4195728F462;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3195869\n");
-    end
-    x = 64'h402FFFFFEFFFFFFE;
-    y = 64'hC000000000000001;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3196483\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h41AAD58B6045CD6B;
-    z = 64'hC10A304B72BC6F6B;
-    ans = 64'hC10A304B72BC6F6B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3197097\n");
-    end
-    x = 64'h37FA903A0F051747;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h1580001FFFFFFFFA;
-    ans = 64'hB81A903A0F051746;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3197711\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hBD7000FFFFFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3198325\n");
-    end
-    x = 64'h409FFFFFFE007FFF;
-    y = 64'hBFF0000800001FFE;
-    z = 64'hC03FFF7EFFFFFFFF;
-    ans = 64'hC0A04006FD005F7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3198939\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hC010000000000001;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h3FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3199553\n");
-    end
-    x = 64'hB7FFFFFFFFFFFFF6;
-    y = 64'h3F9FFFFFEFFFFFFB;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'hB7AFFFFFEFFFFFF1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3200167\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h30E0007FF8000000;
-    ans = 64'h30E0007FF8000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3200781\n");
-    end
-    x = 64'h2403E22FEBFF5C8C;
-    y = 64'hA2700000001FF000;
-    z = 64'hFFF2D8FC1EB17C85;
-    ans = 64'hFFFAD8FC1EB17C85;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3201395\n");
-    end
-    x = 64'h439080FFFFFFFFFE;
-    y = 64'hC340000000000000;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'hC6E080FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3202009\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h4007FFFFDFFFFFFF;
-    z = 64'hC800000003FFFFFF;
-    ans = 64'hC800000003FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3202623\n");
-    end
-    x = 64'h7FEFBFEFFFFFFFFF;
-    y = 64'hC340000000000001;
-    z = 64'hBF32430CFD082394;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3203237\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hBFCDCBE729492DEC;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3203851\n");
-    end
-    x = 64'hB97FFFFFFFFFF80F;
-    y = 64'hBE3FFFFFFFFFFFFF;
-    z = 64'h43F0001FFFEFFFFF;
-    ans = 64'h43F0001FFFEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3204465\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hFFE0000000000000;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3205079\n");
-    end
-    x = 64'h43D1A8D2E24A2428;
-    y = 64'hC3DFFFE000000020;
-    z = 64'h0000000000000000;
-    ans = 64'hC7C1A8C1397741F0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3205693\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hFFE0000000000001;
-    z = 64'hC1FFBFFFDFFFFFFE;
-    ans = 64'hC1FFBFFFDFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3206307\n");
-    end
-    x = 64'hB76008000FFFFFFF;
-    y = 64'h41F000000000080F;
-    z = 64'hC1E5F2F67AF51AB8;
-    ans = 64'hC1E5F2F67AF51AB8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3206921\n");
-    end
-    x = 64'hEB6FFFF9FFFFFFFE;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h4010000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3207535\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'h43DFC007FFFFFFFE;
-    z = 64'h08BFFEFFC0000000;
-    ans = 64'h08BFFEFFC0000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3208149\n");
-    end
-    x = 64'hC1FFFFFFE0000400;
-    y = 64'hFFF0000000000000;
-    z = 64'h3FF00003C0000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3208763\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hBFDFFFFFF0003FFE;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3209377\n");
-    end
-    x = 64'h6D4BFFFFFFFFFBFF;
-    y = 64'h3FB000007FE00000;
-    z = 64'hBFD1FFFFFFFFFFFF;
-    ans = 64'h6D0C0000DFC7FBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3209991\n");
-    end
-    x = 64'h8000000000000001;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h3FE0000000000000;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3210605\n");
-    end
-    x = 64'hC291007FFFFFFFFF;
-    y = 64'hBF200114E0E1C872;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3211219\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h0000000000000000;
-    z = 64'hC1DFFFFFFFF7FFFB;
-    ans = 64'hC1DFFFFFFFF7FFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3211833\n");
-    end
-    x = 64'hBFF410E3E7C9D4AF;
-    y = 64'hB98000003FFFBFFE;
-    z = 64'h3FEFFFFFFFF80080;
-    ans = 64'h3FEFFFFFFFF80080;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3212447\n");
-    end
-    x = 64'h3FAC000000000020;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3213061\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h801FFFE800000000;
-    z = 64'hC3CFFFFFFE000010;
-    ans = 64'hC3CFFFFFFE000010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3213675\n");
-    end
-    x = 64'h39D062BBD0CEA065;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h55F10AD99CB7744A;
-    ans = 64'h55F10AD99CB7744A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3214289\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h3816EC8373D1D7C4;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3214903\n");
-    end
-    x = 64'h37EFFFFFFF7FFF7F;
-    y = 64'hC0AFFFFFFFFC0020;
-    z = 64'hCF5FFF0000000007;
-    ans = 64'hCF5FFF0000000007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3215517\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3216131\n");
-    end
-    x = 64'hBFC8A99A7068420A;
-    y = 64'hC63FFFFEFFBFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3216745\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h409FFFDFFFFFFEFF;
-    ans = 64'h409FFFDFFFFFFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3217359\n");
-    end
-    x = 64'hB30F00000000007F;
-    y = 64'hC03FFFFFFFFFFFF3;
-    z = 64'hBFF0010000400000;
-    ans = 64'hBFF0010000400000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3217973\n");
-    end
-    x = 64'h41D3FFFFFFFFFFFC;
-    y = 64'h3CA0000000000001;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h4000000013FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3218587\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hC02704BE5CEB7478;
-    z = 64'h47F0000FFFFFFFDF;
-    ans = 64'h47F0000FFFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3219201\n");
-    end
-    x = 64'hC01D83A25A3526E3;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hC80FFFFFBFFFFFF7;
-    ans = 64'hC80FFFFFBFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3219815\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hBF903FEFFFFFFFFF;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h801FBF003FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3220429\n");
-    end
-    x = 64'h40800005FFFFFFFF;
-    y = 64'h3FBFFFFF5FFFFFFF;
-    z = 64'hC46FFFFFFFF87FFE;
-    ans = 64'hC46FFFFFFFF87FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3221043\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h3FD0000000000001;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3221657\n");
-    end
-    x = 64'h002FFFF00003FFFF;
-    y = 64'hBCEFFFFFFF6FFFFE;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3222271\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hBF30040003FFFFFF;
-    ans = 64'hBF30040003FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3222885\n");
-    end
-    x = 64'hBE402FFFFFFFFFFF;
-    y = 64'h4DC0000FF7FFFFFE;
-    z = 64'h480FB7FFFFFFFFFE;
-    ans = 64'hCC10301027E7FFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3223499\n");
-    end
-    x = 64'h66B0000020003FFE;
-    y = 64'h3FE0000000000000;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h66A0000020003FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3224113\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hC3FF800000000006;
-    z = 64'h582FFFF001000000;
-    ans = 64'h582FFFF001000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3224727\n");
-    end
-    x = 64'h41F1FBFFFFFFFFFE;
-    y = 64'h3FE0000000000001;
-    z = 64'hBAAFC00000000800;
-    ans = 64'h41E1FBFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3225341\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hC9E000000FFFEFFF;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h0A0000000FFFEFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3225955\n");
-    end
-    x = 64'h3FC4D5E06C217663;
-    y = 64'h3FEFFFFBFFFEFFFF;
-    z = 64'hBFE26C4F295F227E;
-    ans = 64'hBFDA6DAF6A0BE3E4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3226569\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h3FF0000000000000;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h000FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3227183\n");
-    end
-    x = 64'hC03FFFFFFFE7FFFE;
-    y = 64'h41EF800000020000;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000FBFFFFFF5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3227797\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h3FF0000000000001;
-    z = 64'h3F6FF3FFFFFFFFFF;
-    ans = 64'h3F6FF3FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3228411\n");
-    end
-    x = 64'h800FFFFFFFDDFFFF;
-    y = 64'hC7EFFFDFFFFF7FFF;
-    z = 64'hC0381267393B2AC0;
-    ans = 64'hC0381267393B2AC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3229025\n");
-    end
-    x = 64'hC3C28B314BB3DDF5;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h3FE0000000000000;
-    ans = 64'hC3D28B314BB3DDF4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3229639\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hC00000007FFFDFFF;
-    z = 64'hBFCFBFFBFFFFFFFE;
-    ans = 64'hBFCFBFFBFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3230253\n");
-    end
-    x = 64'hC1DFFFDFFFE00000;
-    y = 64'h4000000000000000;
-    z = 64'hBFE6B54C63D18D14;
-    ans = 64'hC1EFFFDFFFF6B54C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3230867\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hC0E0000400FFFFFE;
-    z = 64'h8000000000000000;
-    ans = 64'h0100000400FFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3231481\n");
-    end
-    x = 64'hC020000000021FFF;
-    y = 64'h381000000005FFFE;
-    z = 64'h403FFF8001FFFFFF;
-    ans = 64'h403FFF8001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3232095\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h0010000000000000;
-    ans = 64'h8027FFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3232709\n");
-    end
-    x = 64'h1DCC4CEF5FBE077C;
-    y = 64'hC19F001FFFFFFFFE;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3233323\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h4010000000000000;
-    z = 64'hC3F0000000200100;
-    ans = 64'hC3F0000000200100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3233937\n");
-    end
-    x = 64'h0020000200000000;
-    y = 64'h3FF001FFFFFFFF7F;
-    z = 64'h418FAFFFFFFFFFFE;
-    ans = 64'h418FAFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3234551\n");
-    end
-    x = 64'h6B1FFFFFFFFFFF87;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h3FD0000000000001;
-    ans = 64'h6B4FFFFFFFFFFF86;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3235165\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hBE201FBFFFFFFFFE;
-    z = 64'h43399FFC4505CB9F;
-    ans = 64'h43399FFC4505CB9F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3235779\n");
-    end
-    x = 64'hC7F000001FFFFDFF;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hBCA008000003FFFE;
-    ans = 64'hC82000001FFFFDFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3236393\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h40E02F860C526F0C;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3237007\n");
-    end
-    x = 64'h3FD000000000040F;
-    y = 64'hC02BC23F1AA21C79;
-    z = 64'hC3030C02BE2724D5;
-    ans = 64'hC3030C02BE2724F1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3237621\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h0000000000000001;
-    ans = 64'h836FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3238235\n");
-    end
-    x = 64'hBFC9124AC36DEE47;
-    y = 64'hC40DC17423A58077;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'h43E7502512430022;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3238849\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h067FFFFF00000000;
-    ans = 64'h067FFFFEFFFFFFF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3239463\n");
-    end
-    x = 64'hBF900001FFFFE000;
-    y = 64'hBFCCDA9EA48F1915;
-    z = 64'hC06FEFFFFFFFEFFF;
-    ans = 64'hC06FEFE3255DB01C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3240077\n");
-    end
-    x = 64'hCAAF062EF62EA325;
-    y = 64'h7FE0000000000001;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3240691\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h401FFF800001FFFF;
-    z = 64'h4003C8CC6DA57FC4;
-    ans = 64'h4003C8CC6DA57FC4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3241305\n");
-    end
-    x = 64'hC360000002040000;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h3ECFFFFFFDFFFF7F;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3241919\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h3FD1000000FFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3242533\n");
-    end
-    x = 64'hB81FFFFFFF7FFDFF;
-    y = 64'hC01F77FFFFFFFFFF;
-    z = 64'h4181B4443EED7538;
-    ans = 64'h4181B4443EED7538;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3243147\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h7FF0000000000000;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3243761\n");
-    end
-    x = 64'h3D9502F76012BACF;
-    y = 64'h3FC19288FA52ABC7;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFF474;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3244375\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h4006369F85AFF3DB;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3244989\n");
-    end
-    x = 64'h43500000000007DF;
-    y = 64'h3E7F800004000000;
-    z = 64'h271FFFFFFFFFFFFF;
-    ans = 64'h41DF800004000F7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3245603\n");
-    end
-    x = 64'h400FFFEF00000000;
-    y = 64'h8000000000000000;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h001FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3246217\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h38136AC1C6F3DA6D;
-    z = 64'hC3D0000000000000;
-    ans = 64'hC3D0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3246831\n");
-    end
-    x = 64'hC0AF0000FFFFFFFE;
-    y = 64'h8000000000000001;
-    z = 64'hCBBF9EF686B069CF;
-    ans = 64'hCBBF9EF686B069CF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3247445\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h41C003FFFFFBFFFF;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3248059\n");
-    end
-    x = 64'hBFDD4485F626299F;
-    y = 64'hBFC0000000100FFF;
-    z = 64'h2C203FFFDFFFFFFF;
-    ans = 64'h3FAD4485F6438B68;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3248673\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3249287\n");
-    end
-    x = 64'h001FFFFFF7FFFFEE;
-    y = 64'hC01DFFFFFFFFFFFD;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3249901\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h8010000000000001;
-    z = 64'hC0632F971E01269A;
-    ans = 64'hC0632F971E01269A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3250515\n");
-    end
-    x = 64'hC070000008000800;
-    y = 64'hC3F5AE6BDDD0E4AC;
-    z = 64'hBFBA87175AC889D8;
-    ans = 64'h4475AE6BE8A82572;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3251129\n");
-    end
-    x = 64'hAC6158E30C284003;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h0010000000000000;
-    ans = 64'h0010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3251743\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h3FE1A16DB80FAC6F;
-    z = 64'h47FE44C8F9A9F8E7;
-    ans = 64'h47FE44C8F9A9F8E7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3252357\n");
-    end
-    x = 64'hC0F2000000004000;
-    y = 64'hBCA0000000000000;
-    z = 64'h38100007E0000000;
-    ans = 64'h3DA2000000004000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3252971\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h4710200000200000;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3253585\n");
-    end
-    x = 64'hC2C2003FFFFFFFFF;
-    y = 64'h43F003FFFFFFFDFF;
-    z = 64'h47EFFC0000000000;
-    ans = 64'h47EFFBFB7ECFFC00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3254199\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3254813\n");
-    end
-    x = 64'hC1D000000003FFFE;
-    y = 64'hC03000FF7FFFFFFF;
-    z = 64'hBFE0000000000001;
-    ans = 64'h421000FF8002003D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3255427\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hBFD0000000000000;
-    z = 64'h37E68BA030530633;
-    ans = 64'h37E68BA030530633;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3256041\n");
-    end
-    x = 64'hFFDE1BB9448ED97D;
-    y = 64'hC1F7FFFFFBFFFFFE;
-    z = 64'h3F2FFF001FFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3256655\n");
-    end
-    x = 64'h41EFFFFFEFFBFFFE;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h0000000000000001;
-    ans = 64'hC1DFFFFFEFFBFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3257269\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hB8154E3AC4D65B24;
-    z = 64'h7FEFFFBFFFFFFFF8;
-    ans = 64'h7FEFFFBFFFFFFFF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3257883\n");
-    end
-    x = 64'hC03FFFFF9FFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h7FF1A6DF1C455395;
-    ans = 64'h7FF9A6DF1C455395;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3258497\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hE41FB4561FAB2216;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3259111\n");
-    end
-    x = 64'h3979F06890CEA607;
-    y = 64'h43DFFFF000FFFFFF;
-    z = 64'h3E0020001FFFFFFF;
-    ans = 64'h3E00267C36E65A77;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3259725\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hBFE0000000000001;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3260339\n");
-    end
-    x = 64'h381DFFDFFFFFFFFE;
-    y = 64'hDE8FBFFFFFFF7FFF;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hD6BDC3E03FFF87FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3260953\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h3E59CC299DB7AD28;
-    ans = 64'h3E59CC299DB7AD28;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3261567\n");
-    end
-    x = 64'hC0357882E409903D;
-    y = 64'h413F000200000000;
-    z = 64'h3FF0000000FFFFDF;
-    ans = 64'hC184CCC01C7171FB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3262181\n");
-    end
-    x = 64'hC04F7439462990DF;
-    y = 64'hBFF0000000000000;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3262795\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hC1C0000401FFFFFF;
-    z = 64'h49FEFFFFFFFFEFFF;
-    ans = 64'h49FEFFFFFFFFEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3263409\n");
-    end
-    x = 64'h3E7FFFFFFEFC0000;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h41C0EA1AD0C683E5;
-    ans = 64'h41C0EA1AD0C683E3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3264023\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h3FDCE1B5FD249CA2;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3264637\n");
-    end
-    x = 64'h4D70000080000200;
-    y = 64'hB815E6661713B195;
-    z = 64'hC270400000000006;
-    ans = 64'hC595E666C646E50E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3265251\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hC000000000000000;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3265865\n");
-    end
-    x = 64'hBFF0000000013FFF;
-    y = 64'h0010000000800002;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBCAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3266479\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hBC0FFFFFFFFBDFFF;
-    ans = 64'hBC0FFFFFFFFBDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3267093\n");
-    end
-    x = 64'h43F1400000000000;
-    y = 64'h7FF1FFFFFFFFF7FF;
-    z = 64'hC03376A99788577F;
-    ans = 64'h7FF9FFFFFFFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3267707\n");
-    end
-    x = 64'hC03FFFFEFFFC0000;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3268321\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h3CA9266BE80A93FD;
-    z = 64'h3FE0000000000002;
-    ans = 64'h3FE0000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3268935\n");
-    end
-    x = 64'h3E40000000002800;
-    y = 64'hC010000000000001;
-    z = 64'hC1FFCEF695EE509D;
-    ans = 64'hC1FFCEF695EE509D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3269549\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h43D0000001F7FFFF;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3270163\n");
-    end
-    x = 64'h40100001FFFFFFFA;
-    y = 64'h268FFC000000FFFF;
-    z = 64'hC7FBC385A0705522;
-    ans = 64'hC7FBC385A0705522;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3270777\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3271391\n");
-    end
-    x = 64'h5BC00000000001FB;
-    y = 64'hC32FF769DD7FB534;
-    z = 64'hBCA0000000000000;
-    ans = 64'hDEFFF769DD7FB929;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3272005\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hC340000000000001;
-    z = 64'h37F3BB17F4F23CA5;
-    ans = 64'h37F3BB17F4F23CA5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3272619\n");
-    end
-    x = 64'hC1C16F9BFFD282C8;
-    y = 64'h402FFF8000000007;
-    z = 64'hAF200807FFFFFFFF;
-    ans = 64'hC2016F5641628382;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3273233\n");
-    end
-    x = 64'h001FFFFFFFFFF0FF;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3273847\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h0011FE8BFC8537FA;
-    z = 64'hBD5FFFFFFFF7FFFE;
-    ans = 64'hBD5FFFFFFFF7FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3274461\n");
-    end
-    x = 64'hC2E0002000000040;
-    y = 64'hFFE0000000000000;
-    z = 64'h435AC2FE89704E9A;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3275075\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h7FF7FFFFDFFFFFFF;
-    z = 64'h3FF0000000000000;
-    ans = 64'h7FFFFFFFDFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3275689\n");
-    end
-    x = 64'h444FFFFA00000000;
-    y = 64'hC49FDFFFBFFFFFFE;
-    z = 64'h491FFFFFFFFEFFFF;
-    ans = 64'h491808018E7EFCFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3276303\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hC000000000000000;
-    ans = 64'h3FFFFFFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3276917\n");
-    end
-    x = 64'h3FE7F167081042E5;
-    y = 64'hACCFFFFFFBFF8000;
-    z = 64'h8010000000000001;
-    ans = 64'hACC7F1670511B63E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3277531\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'hFFF0000000000000;
-    z = 64'h3A2000007FFFFBFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3278145\n");
-    end
-    x = 64'hBF8FFFFFFFC01000;
-    y = 64'h001FEFFFFFFFFFFC;
-    z = 64'h396FFFFFFFFFFC7F;
-    ans = 64'h396FFFFFFFFFFC7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3278759\n");
-    end
-    x = 64'h37EFF0F499363D92;
-    y = 64'hFFF0000000000001;
-    z = 64'hC340000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3279373\n");
-    end
-    x = 64'h800FFFFFFFFFFFFF;
-    y = 64'h43EFFFF7FFFFFFFD;
-    z = 64'h412E65857660BD6A;
-    ans = 64'h412E65857660BD6A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3279987\n");
-    end
-    x = 64'h3D8FFF7FFFEFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h8010FFFF7FFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3280601\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h000FFF0000001FFE;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3281215\n");
-    end
-    x = 64'h457F003FFFFFFFFF;
-    y = 64'h3F40000000000102;
-    z = 64'h002C04D8F9B9A9E4;
-    ans = 64'h44CF0040000001F3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3281829\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h0000000000000001;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3282443\n");
-    end
-    x = 64'h4A0FFFFFFFFCFFFE;
-    y = 64'h37FFFFFFFF040000;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h421FFFFFFF00FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3283057\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h001000000FFFFBFE;
-    ans = 64'h001000000FFFFBFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3283671\n");
-    end
-    x = 64'h800FFDFFFFFFFBFF;
-    y = 64'hBFAFDFFFF7FFFFFE;
-    z = 64'hBF11000000000400;
-    ans = 64'hBF11000000000400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3284285\n");
-    end
-    x = 64'hC1F0001FFFFFBFFF;
-    y = 64'h0010000000000000;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3284899\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h40403FFFFFFFFFFD;
-    z = 64'hAB0FDFFFFFFFFDFF;
-    ans = 64'hAB0FDFFFFFFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3285513\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h480FC40000000000;
-    ans = 64'h480FC40000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3286127\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h80070F523EA30032;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3286741\n");
-    end
-    x = 64'hC100FFFFFFFFEFFF;
-    y = 64'h7FFF83FFFFFFFFFE;
-    z = 64'hA2DFFFFFBFFFFFE0;
-    ans = 64'h7FFF83FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3287355\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h3CA0000000000000;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3287969\n");
-    end
-    x = 64'h43DFFFFFFF0003FF;
-    y = 64'h42FA8B901194A63F;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3288583\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hC7E80000001FFFFF;
-    ans = 64'hC7E80000001FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3289197\n");
-    end
-    x = 64'h000FF00000001000;
-    y = 64'h41EFFFFFFFFFFCFF;
-    z = 64'h43FFFFFFBFC00000;
-    ans = 64'h43FFFFFFBFC00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3289811\n");
-    end
-    x = 64'h3FFFA9456A66B8C6;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3290425\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h35CFFFFBFFFFFFFE;
-    z = 64'h43F00800003FFFFE;
-    ans = 64'h43F00800003FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3291039\n");
-    end
-    x = 64'h7FEEA44E583282BA;
-    y = 64'h3FD0000000000001;
-    z = 64'h404FFFF7FFFBFFFF;
-    ans = 64'h7FCEA44E583282BC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3291653\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hB480000000000FF7;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3292267\n");
-    end
-    x = 64'h3E2FFFFF80003FFF;
-    y = 64'h4030FFFFFFFFFFFF;
-    z = 64'hC44FBFFFFFFFFFF7;
-    ans = 64'hC44FBFFFFFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3292881\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3293495\n");
-    end
-    x = 64'hB2CFFF8000000001;
-    y = 64'hB88FFFFFFFFDF000;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3294109\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h3FE0000000000001;
-    z = 64'h0010000400000010;
-    ans = 64'h0008000400000011;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3294723\n");
-    end
-    x = 64'h3F907FFF00000000;
-    y = 64'h40500007FFFFE000;
-    z = 64'hC1DFFFFFFFE04000;
-    ans = 64'hC1DFFFFFFF9E3FE3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3295337\n");
-    end
-    x = 64'hB3300007FDFFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3295951\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hC00619E1A258A831;
-    z = 64'h434FDFFC00000000;
-    ans = 64'h434FDFFC00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3296565\n");
-    end
-    x = 64'h002F0007FFFFFFFE;
-    y = 64'h3FF0000000000000;
-    z = 64'h40C0000003FFFFFC;
-    ans = 64'h40C0000003FFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3297179\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h801FFFF7FBFFFFFE;
-    z = 64'h3CA0000000000000;
-    ans = 64'h3CA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3297793\n");
-    end
-    x = 64'hB27102DF0BD0BADE;
-    y = 64'hA57FFFFFA0000000;
-    z = 64'hBA727FFFFFFFFFFE;
-    ans = 64'hBA727FFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3298407\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3299021\n");
-    end
-    x = 64'hBFB9F8E9AE43667C;
-    y = 64'hB7FFFE00000003FE;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3299635\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h4000000000000000;
-    z = 64'h405000027FFFFFFF;
-    ans = 64'h405000027FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3300249\n");
-    end
-    x = 64'hC0103FDFFFFFFFFF;
-    y = 64'h5D1000001000000F;
-    z = 64'hAE6CFD66D57C4A6B;
-    ans = 64'hDD303FE0103FE00E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3300863\n");
-    end
-    x = 64'h3FE00203FFFFFFFF;
-    y = 64'h4000000000000001;
-    z = 64'hBFF0000000000001;
-    ans = 64'h3F401FFFFFFFF801;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3301477\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h3850000007FFFFFC;
-    z = 64'h41E8000000004000;
-    ans = 64'h41E8000000004000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3302091\n");
-    end
-    x = 64'hAA7000000010FFFF;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h0FE000400007FFFF;
-    ans = 64'hAA9000000010FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3302705\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h001FBFFFFFBFFFFE;
-    z = 64'h0010000000000001;
-    ans = 64'h0010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3303319\n");
-    end
-    x = 64'h3ED0000000C00000;
-    y = 64'h3FDBCD5857809B86;
-    z = 64'hC03BFFFFFF7FFFFF;
-    ans = 64'hC03BFFFFE3B2A7A6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3303933\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h4010000000000001;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3304547\n");
-    end
-    x = 64'hC2FFFFFFBFFFBFFE;
-    y = 64'h404FFFFFE1FFFFFF;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFF43FF8073;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3305161\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h43CFFFFFFFFFEFFE;
-    ans = 64'h43CFFFFFFFFFEFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3305775\n");
-    end
-    x = 64'hFFE0020000003FFF;
-    y = 64'hBF40000000FFFFFC;
-    z = 64'h0000003FFDFFFFFF;
-    ans = 64'h7F30020001005FFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3306389\n");
-    end
-    x = 64'h41E0000010004000;
-    y = 64'h4340000000000000;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'h4530000010004000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3307003\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hBD3FFFFC0000007F;
-    z = 64'h3FDFFFFFBFFFFDFF;
-    ans = 64'h3FDFFFFFBFFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3307617\n");
-    end
-    x = 64'h434A579E176B14FB;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h43EFFFFFFF7FFFFE;
-    ans = 64'h46AA579E176B16FA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3308231\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h3FD0000000007FFE;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h000BFFFFFFFFE000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3308845\n");
-    end
-    x = 64'h47F0000007FC0000;
-    y = 64'hC5C08003FFFFFFFF;
-    z = 64'hB68FFEFFFFFDFFFF;
-    ans = 64'hCDC08004083BE1FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3309459\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h7FE0000000000000;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3310073\n");
-    end
-    x = 64'h400EEFFFFFFFFFFF;
-    y = 64'hBF1FFDFFFFFFE000;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFF8447BBFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3310687\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h3CA5272068BFA9C0;
-    ans = 64'hC00FFFFFFFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3311301\n");
-    end
-    x = 64'h4A5FFFFFFFFDFEFF;
-    y = 64'hC1DFFFFFFFBDFFFF;
-    z = 64'hC1EFC0000000003F;
-    ans = 64'hCC4FFFFFFFBBFEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3311915\n");
-    end
-    x = 64'h419007FFFFFFFFBF;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3312529\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h9FBCFFFFFFFFFFFF;
-    z = 64'hADE01FF7FFFFFFFF;
-    ans = 64'hADE01FF7FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3313143\n");
-    end
-    x = 64'hBFFCF103D80A58EE;
-    y = 64'h7FF0000000000001;
-    z = 64'hB7F8B48F2C8A4C4D;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3313757\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h66AFFFFFFFFFBFEF;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3314371\n");
-    end
-    x = 64'h3FBFFFE000000100;
-    y = 64'h401FED37CFC20DEA;
-    z = 64'hC10000000000027F;
-    ans = 64'hC0FFFFF0097413B9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3314985\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3315599\n");
-    end
-    x = 64'h414FFFC007FFFFFF;
-    y = 64'hDC73D5385DFE4F27;
-    z = 64'h4010000000000000;
-    ans = 64'hDDD3D510B882E141;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3316213\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h8000000000000001;
-    z = 64'h403FFFFFFFFEFFEF;
-    ans = 64'h403FFFFFFFFEFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3316827\n");
-    end
-    x = 64'hFFD000008000007F;
-    y = 64'hC0099588A9B1AE8D;
-    z = 64'h3D5F81AF27B7463A;
-    ans = 64'h7FE99589765DF4A6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3317441\n");
-    end
-    x = 64'h47EFFFFF7FFFFFFF;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3318055\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h3D3FDFFFFFFFC000;
-    z = 64'hE7800010FFFFFFFE;
-    ans = 64'hE7800010FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3318669\n");
-    end
-    x = 64'h3E0F7FBFFFFFFFFE;
-    y = 64'h8010000000000000;
-    z = 64'hC010FF7FFFFFFFFF;
-    ans = 64'hC010FF7FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3319283\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hC500000007FFFFFA;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3319897\n");
-    end
-    x = 64'hC1EFFFFFFF080000;
-    y = 64'hB7FF4C5FEC06BFEE;
-    z = 64'hC3FB1197B5C63C71;
-    ans = 64'hC3FB1197B5C63C71;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3320511\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h8000000000000000;
-    ans = 64'h0000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3321125\n");
-    end
-    x = 64'hCD3EFFFFFFFFFC00;
-    y = 64'hC7E10000000FFFFF;
-    z = 64'h4000000000000001;
-    ans = 64'h55307800000F7DDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3321739\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hBCA0000000000000;
-    z = 64'h3FE01FFFDFFFFFFF;
-    ans = 64'h3FE01FFFDFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3322353\n");
-    end
-    x = 64'hC0F0000000F7FFFF;
-    y = 64'hC1DF7FEFFFFFFFFE;
-    z = 64'h4E2E00000000003F;
-    ans = 64'h4E2E00000000003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3322967\n");
-    end
-    x = 64'h43C3FFFFFFC00000;
-    y = 64'hBCA0000000000001;
-    z = 64'hBCA0000000000001;
-    ans = 64'hC073FFFFFFC00001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3323581\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h43DFFFFFFFFE000F;
-    z = 64'hC3C000000FF80000;
-    ans = 64'hC3C000000FF80000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3324195\n");
-    end
-    x = 64'h8020800000000008;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hBFC0800000000001;
-    ans = 64'hBFC0800000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3324809\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h4349D797CF3BC3F4;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3325423\n");
-    end
-    x = 64'hBF9000007EFFFFFF;
-    y = 64'h4348DF378B8A6FE1;
-    z = 64'hCE00001FFFFFFFF7;
-    ans = 64'hCE00001FFFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3326037\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hBFD0000000000001;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3326651\n");
-    end
-    x = 64'hB5CFFFFBFF7FFFFF;
-    y = 64'h3FF0000000200000;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h3FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3327265\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h3B9FFFFE02000000;
-    ans = 64'h3B9FFFFE02000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3327879\n");
-    end
-    x = 64'hBFFFFFFE20000000;
-    y = 64'h4DD00007FFFF7FFE;
-    z = 64'hB93E9C46925C398F;
-    ans = 64'hCDE000070FFF07FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3328493\n");
-    end
-    x = 64'hBFCFFE0000000100;
-    y = 64'hBFE0000000000000;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h3FBFFE0000000100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3329107\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hBFE0000003FFFFFF;
-    z = 64'hC1CFFFFFFF7E0000;
-    ans = 64'hC1CFFFFFFF7E0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3329721\n");
-    end
-    x = 64'hC7E0000103FFFFFF;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hC3FFEFFFFEFFFFFF;
-    ans = 64'h47E0000103FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3330335\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h8020000803FFFFFE;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3330949\n");
-    end
-    x = 64'hB0D06C48D23CE86B;
-    y = 64'hC1C73954256DB898;
-    z = 64'h47F9EFC1D9AD8521;
-    ans = 64'h47F9EFC1D9AD8521;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3331563\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hBFF0000000000000;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3332177\n");
-    end
-    x = 64'hC7EFFFDFFFFDFFFF;
-    y = 64'hC98FE00000000000;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h518FDFE01FFE01FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3332791\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hBFF0000000000001;
-    z = 64'h94D020000000001F;
-    ans = 64'h94D020000000001F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3333405\n");
-    end
-    x = 64'hC0300800003FFFFE;
-    y = 64'h8001FFFFF7FFFFFF;
-    z = 64'hC1D075BF2C245F2A;
-    ans = 64'hC1D075BF2C245F2A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3334019\n");
-    end
-    x = 64'h400F6470568463BB;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hC01F6470568463B9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3334633\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hBFDF31A46F1F02A3;
-    z = 64'hBFB0FFFFFFFFFFF7;
-    ans = 64'hBFB0FFFFFFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3335247\n");
-    end
-    x = 64'hC01000000017FFFE;
-    y = 64'hC000000000000001;
-    z = 64'hEBAFFFFFFFE0003F;
-    ans = 64'hEBAFFFFFFFE0003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3335861\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h7FF0ECF8BC191E65;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'h7FF8ECF8BC191E65;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3336475\n");
-    end
-    x = 64'h7FFFFFFFFFFFFEF7;
-    y = 64'hCABFF7FFFFFFFFE0;
-    z = 64'h7FD00001FFFF7FFE;
-    ans = 64'h7FFFFFFFFFFFFEF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3337089\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3337703\n");
-    end
-    x = 64'hC3C077FFFFFFFFFF;
-    y = 64'h8000000000002010;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3338317\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hC010000000000000;
-    z = 64'h800DFEDE47FBC1E2;
-    ans = 64'h00290090DC021F0B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3338931\n");
-    end
-    x = 64'hBFC494FAB48A29ED;
-    y = 64'h3800000200000FFE;
-    z = 64'h9FAFEBFFFFFFFFFF;
-    ans = 64'hB7D494FD47299511;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3339545\n");
-    end
-    x = 64'h7FDBFFFFFBFFFFFF;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h8000000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3340159\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h434FFFC008000000;
-    z = 64'hFFEFFFFFFFF8001F;
-    ans = 64'hFFEFFFFFFFF8001F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3340773\n");
-    end
-    x = 64'h418FFDFF80000000;
-    y = 64'hC340000000000000;
-    z = 64'hC02FFFFFFFFF003F;
-    ans = 64'hC4DFFDFF80000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3341387\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h43E0040000000000;
-    z = 64'hC010000000000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3342001\n");
-    end
-    x = 64'h00200005FFFFFFFE;
-    y = 64'h950FFFFF7FFFFFF0;
-    z = 64'hB8039E96058D8A71;
-    ans = 64'hB8039E96058D8A71;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3342615\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3343229\n");
-    end
-    x = 64'hC34FFC00000FFFFF;
-    y = 64'h41C7FFFFFFFFFFFE;
-    z = 64'h3FD0000000000001;
-    ans = 64'hC527FD00000BFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3343843\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h41D041FFFFFFFFFE;
-    ans = 64'h41D041FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3344457\n");
-    end
-    x = 64'hC030000000001FFE;
-    y = 64'hB8178767331561B7;
-    z = 64'h3DA0080000000080;
-    ans = 64'h3DA0080000000080;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3345071\n");
-    end
-    x = 64'hD1F00007FE000000;
-    y = 64'hFFE0000000000001;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3345685\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'h37FFFFFFFFFFFD7F;
-    z = 64'h3F3FFF800000007E;
-    ans = 64'h3F3FFF800000007E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3346299\n");
-    end
-    x = 64'h000FFFEFDFFFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h4014569BF0D38E3F;
-    ans = 64'h3FF15AB0434E3904;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3346913\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hC7F00E76DCEA4AE9;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3347527\n");
-    end
-    x = 64'h3FCFFFFFFFEFFFF6;
-    y = 64'h4050008000000010;
-    z = 64'hC1FFEFFFEFFFFFFE;
-    ans = 64'hC1FFEFFFEEFFF7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3348141\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hFFF0000000000001;
-    z = 64'h4010000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3348755\n");
-    end
-    x = 64'h4003FFFFFFFFFFFC;
-    y = 64'h3B9FFFFFFFFFFF87;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CB00013FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3349369\n");
-    end
-    x = 64'h800FFFFFFFFFFFFE;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hBF51FFFFC0000000;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3349983\n");
-    end
-    x = 64'h42007FFFFFFFFFFE;
-    y = 64'hC05FFFFFFFDFE000;
-    z = 64'h7FF010000000000E;
-    ans = 64'h7FF810000000000E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3350597\n");
-    end
-    x = 64'h3FD0000000BFFFFE;
-    y = 64'h0000000000000000;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3351211\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hC03FFFFBFFFFF800;
-    z = 64'h3EEFFFFFFFFFFFDD;
-    ans = 64'h3EEFFFFFFFFFFFDD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3351825\n");
-    end
-    x = 64'hC7EFFFFFFFFFFDFF;
-    y = 64'h0000000000000001;
-    z = 64'hBF6FFFFF03FFFFFE;
-    ans = 64'hBF6FFFFF03FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3352439\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hBD4FFFFFFFFFF7FF;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3353053\n");
-    end
-    x = 64'h47F0000000082000;
-    y = 64'h37FF5000285F803E;
-    z = 64'h3FEFFE0000000100;
-    ans = 64'h4007A7801437B3AF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3353667\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h0010000000000000;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3354281\n");
-    end
-    x = 64'h3810000000800003;
-    y = 64'h3041E7047E3F25CD;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h2861E7047ECE5DF4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3354895\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h0010000000000001;
-    z = 64'h47F9FFFFFFFFFFFE;
-    ans = 64'h47F9FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3355509\n");
-    end
-    x = 64'hE59F8003FFFFFFFF;
-    y = 64'hBFD02EA216C7C36A;
-    z = 64'h41CFFFFFFF7FEFFF;
-    ans = 64'h657FDBD32881CE6A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3356123\n");
-    end
-    x = 64'hD2F03FFFFBFFFFFE;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3356737\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h402382A8B2E80B9B;
-    z = 64'hBFB0010004000000;
-    ans = 64'hBFB0010004000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3357351\n");
-    end
-    x = 64'h403FF7FFFFFFFFFB;
-    y = 64'h3CA0000000000000;
-    z = 64'h001FBFFFFFFFFDFF;
-    ans = 64'h3CEFF7FFFFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3357965\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h400FFFFFFFC00400;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3358579\n");
-    end
-    x = 64'hBCA00000003FFFFE;
-    y = 64'h7FD79FFD9502BA89;
-    z = 64'hFFE03FF000000000;
-    ans = 64'hFFE03FF000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3359193\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3359807\n");
-    end
-    x = 64'h3E400020FFFFFFFE;
-    y = 64'hC10F7FFBFFFFFFFF;
-    z = 64'h0010000000000000;
-    ans = 64'hBF5F803CF7F7BFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3360421\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h3FD0000000000000;
-    z = 64'hB81FFFFFFFFF80FE;
-    ans = 64'hB81FFFFFFFFF80FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3361035\n");
-    end
-    x = 64'h3FDFFFDFFFF7FFFE;
-    y = 64'h3FF000010FFFFFFE;
-    z = 64'h401FFFBFFFFFF000;
-    ans = 64'h4020FFDF10FFA700;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3361649\n");
-    end
-    x = 64'h3F0FFFBFFFFDFFFE;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3362263\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hC00FFFFFF8001FFF;
-    z = 64'hC7F00000FFFDFFFE;
-    ans = 64'hC7F00000FFFDFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3362877\n");
-    end
-    x = 64'hBFA0003FFFFFF000;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hC049FFFFFFFFFFFF;
-    ans = 64'hC04A020007FFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3363491\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h800FFFDFFFFFDFFF;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3364105\n");
-    end
-    x = 64'hBFDF800000007FFF;
-    y = 64'h380B8EDE6D7386ED;
-    z = 64'hAAF0001FFFFFF000;
-    ans = 64'hB7FB20A2F3BE270C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3364719\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3365333\n");
-    end
-    x = 64'h41EF000000007FFF;
-    y = 64'hBE6FFF7FFFFF7FFF;
-    z = 64'h0000000000000001;
-    ans = 64'hC06EFF84000003FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3365947\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h4060000000100007;
-    ans = 64'h4060000000100007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3366561\n");
-    end
-    x = 64'hBFDFFC90D6E1FC1F;
-    y = 64'h3CA1FFFFFFFFEFFE;
-    z = 64'hBFE66AD464A87AAC;
-    ans = 64'hBFE66AD464A87AAD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3367175\n");
-    end
-    x = 64'h43E00007FFEFFFFE;
-    y = 64'h3FF0000000000001;
-    z = 64'h4010000000000001;
-    ans = 64'h43E00007FFEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3367789\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h522FFFFFFBFBFFFF;
-    z = 64'h7FFFFFFFFFFBFFF7;
-    ans = 64'h7FFFFFFFFFFBFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3368403\n");
-    end
-    x = 64'h37EFFFFFDFFFFF7F;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hC02F5071BEF1B839;
-    ans = 64'hC02F5071BEF1B839;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3369017\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hFFEFFFFF77FFFFFE;
-    z = 64'hBFD0000000000001;
-    ans = 64'h400DFFFF77FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3369631\n");
-    end
-    x = 64'hC7F7EBA22F2EA5FF;
-    y = 64'h40DFFFFF80000002;
-    z = 64'h4061000010000000;
-    ans = 64'hC8E7EBA1CF801D44;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3370245\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h4000000000000001;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3370859\n");
-    end
-    x = 64'hBFE8329734DA71DB;
-    y = 64'hC7EFFF7FFFFFFFFA;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3371473\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h40D0000000013FFF;
-    ans = 64'h40D0000000013FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3372087\n");
-    end
-    x = 64'hB7E4BBDEDAC95C09;
-    y = 64'hF080000000000016;
-    z = 64'hB7EFFFFFF8000003;
-    ans = 64'h6874BBDEDAC95C26;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3372701\n");
-    end
-    x = 64'hCC9FFFFFFF840000;
-    y = 64'h4010000000000000;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'hCCBFFFFFFF840000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3373315\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h57ADB1B7BA5F902C;
-    z = 64'h4340800000FFFFFE;
-    ans = 64'h4340800000FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3373929\n");
-    end
-    x = 64'hBAB0000100000400;
-    y = 64'h4010000000000001;
-    z = 64'hBFBFFF8003FFFFFF;
-    ans = 64'hBFBFFF8003FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3374543\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h7FE00000007FFFC0;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hC0000000007FFFC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3375157\n");
-    end
-    x = 64'h47E14BC9A7ABAD71;
-    y = 64'h7FD29E75366A36B5;
-    z = 64'hEB3FFFFE00000FFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3375771\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h4340000000000000;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3376385\n");
-    end
-    x = 64'hC1F0000000020020;
-    y = 64'hC0E00080007FFFFE;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3376999\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h4340000000000001;
-    z = 64'hC7F400FFFFFFFFFE;
-    ans = 64'hC7F400FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3377613\n");
-    end
-    x = 64'hC1C69CCD52EC0983;
-    y = 64'hD3E00000000FEFFF;
-    z = 64'h0910002000004000;
-    ans = 64'h55B69CCD53028FB2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3378227\n");
-    end
-    x = 64'hFFDA2BDB043076F0;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3378841\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h40707FFFFBFFFFFF;
-    z = 64'h41CFFFC00003FFFF;
-    ans = 64'h41CFFFC00003FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3379455\n");
-    end
-    x = 64'hC16A265035CB0A3D;
-    y = 64'h7FE0000000000000;
-    z = 64'hBFEFFDFFFF000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3380069\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h3FF0000FFFFFFFFD;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h80280007FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3380683\n");
-    end
-    x = 64'h434000FFFFFFE000;
-    y = 64'hA167850B540C93BE;
-    z = 64'h4020100007FFFFFE;
-    ans = 64'h4020100007FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3381297\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3381911\n");
-    end
-    x = 64'h47EE080000000000;
-    y = 64'h3EDFFFF83FFFFFFE;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3382525\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h7FF0000000000000;
-    z = 64'hB81B02DA624F85A3;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3383139\n");
-    end
-    x = 64'h8000000000000201;
-    y = 64'hA6D1000000000040;
-    z = 64'h3E4FFF7DFFFFFFFF;
-    ans = 64'h3E4FFF7DFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3383753\n");
-    end
-    x = 64'h40D3FFFFFF7FFFFF;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h3FF0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3384367\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h401825A58D846616;
-    z = 64'hBFF0FFFBFFFFFFFF;
-    ans = 64'hBFF0FFFBFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3384981\n");
-    end
-    x = 64'h801100000001FFFF;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h3A2401EDCE8EAE88;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3385595\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h4FE000000000077F;
-    z = 64'h8010000000000000;
-    ans = 64'h900000000000077F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3386209\n");
-    end
-    x = 64'h402000001000007F;
-    y = 64'hC3D0000010003FFF;
-    z = 64'h434FFFFFBFFFF7FE;
-    ans = 64'hC3FFFC004008811D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3386823\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h3CA0000000000000;
-    ans = 64'h3CA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3387437\n");
-    end
-    x = 64'h405FF80000000FFF;
-    y = 64'h55200000FFBFFFFF;
-    z = 64'hC340000000000001;
-    ans = 64'h558FF801FF002FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3388051\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h41E953F84305CBE0;
-    ans = 64'h41E953F84305CBE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3388665\n");
-    end
-    x = 64'h9C10100000001FFF;
-    y = 64'h3CA000000000FC00;
-    z = 64'hC1E0B989A320F196;
-    ans = 64'hC1E0B989A320F196;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3389279\n");
-    end
-    x = 64'h38132ABE4909F276;
-    y = 64'h8010000000000001;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3389893\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h30EFFFFFF01FFFFF;
-    z = 64'h3FC232FDBD2A9184;
-    ans = 64'h3FC232FDBD2A9184;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3390507\n");
-    end
-    x = 64'hF3FFFFFF00007FFF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h41E0040000007FFE;
-    ans = 64'h41E0040000007FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3391121\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hFFF0000000008004;
-    z = 64'h8000000000000001;
-    ans = 64'hFFF8000000008004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3391735\n");
-    end
-    x = 64'h24107FFFFFFFFFFE;
-    y = 64'hC0100400000000FE;
-    z = 64'h401DD6230D9BE81D;
-    ans = 64'h401DD6230D9BE81D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3392349\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hBCA0000000000001;
-    z = 64'h0010000000000001;
-    ans = 64'h0010000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3392963\n");
-    end
-    x = 64'h37EFFFFFFF8001FF;
-    y = 64'h40EFFFD7FFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3393577\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h3FEFF7FFBFFFFFFF;
-    ans = 64'h3FEFF7FFBFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3394191\n");
-    end
-    x = 64'h41BFFF7FFFFFFBFE;
-    y = 64'hC0291CCC009FE8EF;
-    z = 64'h7FFFFFFFC000000E;
-    ans = 64'h7FFFFFFFC000000E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3394805\n");
-    end
-    x = 64'hC0120003FFFFFFFF;
-    y = 64'hBFD0000000000000;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FFA0003FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3395419\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h80100000FFFFFDFF;
-    z = 64'h6DC07FFFFFFFBFFF;
-    ans = 64'h6DC07FFFFFFFBFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3396033\n");
-    end
-    x = 64'h3AB6A4F1D7C0B087;
-    y = 64'hBFD0000000000001;
-    z = 64'h3FF00000800000FF;
-    ans = 64'h3FF00000800000FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3396647\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hBF7D582DBB88D647;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3397261\n");
-    end
-    x = 64'hC3E0000002400000;
-    y = 64'h00100003FFFFFFFB;
-    z = 64'h43E08000000000FF;
-    ans = 64'h43E08000000000FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3397875\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hBFE0000000000000;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h0017FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3398489\n");
-    end
-    x = 64'h43FA9DBB168CCA00;
-    y = 64'h417000000000F800;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'h457A9DBB168E668D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3399103\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hBFE0000000000001;
-    z = 64'hBE027E2F4F0BA6BA;
-    ans = 64'hBE027E2F4F0BA6BA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3399717\n");
-    end
-    x = 64'h381FFFFFFE0FFFFE;
-    y = 64'hBF4FFFC002000000;
-    z = 64'h3CADFFFFFFFDFFFF;
-    ans = 64'h3CADFFFFFFFDFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3400331\n");
-    end
-    x = 64'hC04000201FFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h404000201FFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3400945\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hBCAFFFFF7FFFEFFE;
-    z = 64'hC1FFFFF8007FFFFF;
-    ans = 64'hC1FFFFF8007FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3401559\n");
-    end
-    x = 64'hBF1FC01FFFFFFFFE;
-    y = 64'hBFF0000000000000;
-    z = 64'hC3C02000000003FE;
-    ans = 64'hC3C02000000003FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3402173\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h43FD5D2E92764475;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3402787\n");
-    end
-    x = 64'hBE0ED055692EBF18;
-    y = 64'hFFFFFFFFFFFF03FE;
-    z = 64'h37EA1A5EB2077F40;
-    ans = 64'hFFFFFFFFFFFF03FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3403401\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3404015\n");
-    end
-    x = 64'h7FF0010000000007;
-    y = 64'h400FFFFFE0000004;
-    z = 64'hC000000000000000;
-    ans = 64'h7FF8010000000007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3404629\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hC000000000000000;
-    z = 64'h400FFFFFFF7FFFFE;
-    ans = 64'h400FFFFFFF7FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3405243\n");
-    end
-    x = 64'hBF34EA21CDC8CADA;
-    y = 64'hC0800200000FFFFF;
-    z = 64'h401FFFFFFEEFFFFF;
-    ans = 64'h402053B2FBC05DB8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3405857\n");
-    end
-    x = 64'hC9EFFFF800003FFF;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h3CA0000000000000;
-    ans = 64'h4A0FFFF800003FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3406471\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h7FFFFFFFFFDFFFFF;
-    z = 64'h480FFFFFFFEFFC00;
-    ans = 64'h7FFFFFFFFFDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3407085\n");
-    end
-    x = 64'hC81F7FFFFFFFFEFF;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hBF9AE67AFF0983D8;
-    ans = 64'h483F7FFFFFFFFEFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3407699\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h43C3AED15D7EED2D;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3408313\n");
-    end
-    x = 64'h47F00000FFFFBFFF;
-    y = 64'h006FF7FFFFFFFFFB;
-    z = 64'h7FEFF7FF80000000;
-    ans = 64'h7FEFF7FF80000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3408927\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hC010000000000001;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3409541\n");
-    end
-    x = 64'h37F0000003FFFFF7;
-    y = 64'hBF23FFFF7FFFFFFF;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3410155\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h43C8E9C48CCC5395;
-    ans = 64'h43C8E9C48CCC5395;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3410769\n");
-    end
-    x = 64'h3F50F7FFFFFFFFFF;
-    y = 64'hC1E0000017FFFFFF;
-    z = 64'hBFAE4E3B838772A5;
-    ans = 64'hC140F80021078EDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3411383\n");
-    end
-    x = 64'h3FFFFF07FFFFFFFF;
-    y = 64'hC340000000000001;
-    z = 64'h0010000000000001;
-    ans = 64'hC34FFF0800000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3411997\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hBFC1000000000002;
-    z = 64'h37E6F76741D61EDF;
-    ans = 64'h37E6F76741D61EDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3412611\n");
-    end
-    x = 64'h3ED7BBC3B97CC198;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hC7F1001FFFFFFFFF;
-    ans = 64'hC7F1001FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3413225\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hC1FFFFF7FFEFFFFF;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3413839\n");
-    end
-    x = 64'hBFF0000000880000;
-    y = 64'h43DFE00000020000;
-    z = 64'h3C9000000FBFFFFF;
-    ans = 64'hC3DFE0000110F000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3414453\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hFFE0000000000000;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3415067\n");
-    end
-    x = 64'h455004000000003E;
-    y = 64'hC3C38570142B9A35;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hC9238A517030A567;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3415681\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hB7FEFFF7FFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3416295\n");
-    end
-    x = 64'h41CE002000000000;
-    y = 64'h47E74F59B8787E2A;
-    z = 64'h404A24AB53AA6DE2;
-    ans = 64'h49C5DA7B6C4AAEC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3416909\n");
-    end
-    x = 64'h40319890A0A917DD;
-    y = 64'hFFF0000000000000;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3417523\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hC0380007FFFFFFFF;
-    z = 64'hBCAFFFFFFFFEFC00;
-    ans = 64'hBCAFFFFFFFFEFC00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3418137\n");
-    end
-    x = 64'h43E0000FFFFFBFFE;
-    y = 64'hFFF0000000000001;
-    z = 64'hC1EFFBF7FFFFFFFF;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3418751\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'h47EC85E3B2608045;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3419365\n");
-    end
-    x = 64'h4462750B8EBD954D;
-    y = 64'h40366C327960A626;
-    z = 64'h457FC0FFFFFFFFFF;
-    ans = 64'h457FC1CEEE016087;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3419979\n");
-    end
-    x = 64'h8010000000000000;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3420593\n");
-    end
-    x = 64'h8C16F70C4AD7B5FF;
-    y = 64'hC0659F877D27364D;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3421207\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h0000000000000001;
-    z = 64'h40400000001FFFFF;
-    ans = 64'h40400000001FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3421821\n");
-    end
-    x = 64'h3FFFFE7FFFFFFFFF;
-    y = 64'hFFF07FBFFFFFFFFE;
-    z = 64'h37EEAC45D6E6F956;
-    ans = 64'hFFF87FBFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3422435\n");
-    end
-    x = 64'hC090000800000008;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3423049\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h4030000080000400;
-    z = 64'h3814DAE88176666D;
-    ans = 64'h3814DAE88176666D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3423663\n");
-    end
-    x = 64'hC3F00000FFF80000;
-    y = 64'h0010000000000000;
-    z = 64'h58200000000FFF00;
-    ans = 64'h58200000000FFF00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3424277\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hBE5FFFFFFFF9FFFE;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3424891\n");
-    end
-    x = 64'h7FD0FFFC00000000;
-    y = 64'h245FFFFFFFFFFFF6;
-    z = 64'h001E996DE223F216;
-    ans = 64'h6440FFFBFFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3425505\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3426119\n");
-    end
-    x = 64'h327FFFFFFFFF0FFF;
-    y = 64'h002FFFFFF000007E;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3426733\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h3CA0000000000000;
-    z = 64'hBFEBFFFFFFF7FFFE;
-    ans = 64'hBFEBFFFFFFF7FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3427347\n");
-    end
-    x = 64'h3D4AF0C44F073F7C;
-    y = 64'hB7EFFEFFFFFF7FFE;
-    z = 64'hC29271AA05B991D9;
-    ans = 64'hC29271AA05B991D9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3427961\n");
-    end
-    x = 64'h0016FB8958D5CE7A;
-    y = 64'h3CA0000000000001;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3428575\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h40100200000007FE;
-    z = 64'hBE200000000C0000;
-    ans = 64'hBE200000000C0000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3429189\n");
-    end
-    x = 64'h417FFFFFFFFE00FF;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hC3D0800200000000;
-    ans = 64'hC3D0800200000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3429803\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h4EB4F75D91518E6B;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3430417\n");
-    end
-    x = 64'h381FFFFFE3FFFFFE;
-    y = 64'hBFE0000000017FFF;
-    z = 64'h3FB9479D54939987;
-    ans = 64'h3FB9479D54939987;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3431031\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h3FD0000000000001;
-    z = 64'hC010000000000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3431645\n");
-    end
-    x = 64'hC0000000003FFFFF;
-    y = 64'h3FEFFFFFFF801FFF;
-    z = 64'hBCA0000000000001;
-    ans = 64'hC000000000000FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3432259\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hB8F0000003FFFFBE;
-    ans = 64'hB8F0000003FFFFBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3432873\n");
-    end
-    x = 64'h47CFF7FFFFFFFFFF;
-    y = 64'h000403FFFFFFFFFF;
-    z = 64'h4010000010000006;
-    ans = 64'h4010000010000006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3433487\n");
-    end
-    x = 64'h3E1F7FFFFFFDFFFE;
-    y = 64'h3FE0000000000000;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3434101\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hC02FFFFFFFFFFBFE;
-    z = 64'hC3CFFFFFFFFFFFEB;
-    ans = 64'hC3CFFFFFFFFFFFEB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3434715\n");
-    end
-    x = 64'h403FFFFFFBFFFBFF;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h41FFFFFF80000040;
-    ans = 64'h41FFFFFF82000040;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3435329\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hBFCFFFFFFFFEFFF8;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3435943\n");
-    end
-    x = 64'hBFE000800000000E;
-    y = 64'hBF203FFFFFBFFFFE;
-    z = 64'hBFBDA817ACC5E05E;
-    ans = 64'hBFBDA4078C45F05E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3436557\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h3FF0000000000000;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3437171\n");
-    end
-    x = 64'h7FE800000000003E;
-    y = 64'h8004DE935D68D1E8;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'hBFED37743074EBBB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3437785\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hC800000000007FEF;
-    ans = 64'hC800000000007FEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3438399\n");
-    end
-    x = 64'hCD0A506F0E26FC02;
-    y = 64'hBFADFFFFFFFFC000;
-    z = 64'hC5200003FFFBFFFF;
-    ans = 64'h4CC8AB681D4457A1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3439013\n");
-    end
-    x = 64'hBAB03FFFFFFE0000;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3439627\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h26DFFFBFFF800000;
-    z = 64'h40D81EF424CFD2A4;
-    ans = 64'h40D81EF424CFD2A4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3440241\n");
-    end
-    x = 64'hBFC6CE5CC791295B;
-    y = 64'h4000000000000001;
-    z = 64'h4800000010000008;
-    ans = 64'h4800000010000008;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3440855\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hD6C0001FFFFFFFFE;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3441469\n");
-    end
-    x = 64'h0FD00005FFFFFFFF;
-    y = 64'h38002000000001FF;
-    z = 64'h403FFFFFFFFFFF7F;
-    ans = 64'h403FFFFFFFFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3442083\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3442697\n");
-    end
-    x = 64'hBF3FFF8003FFFFFF;
-    y = 64'h3F9005FFFFFFFFFE;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hBEE005BFEA00BFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3443311\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h4010000000000001;
-    z = 64'hC3DFFFFFFF8FFFFF;
-    ans = 64'hC3DFFFFFFF8FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3443925\n");
-    end
-    x = 64'hC1C0000800000010;
-    y = 64'hC801FFFFF0000000;
-    z = 64'h6B00000100000000;
-    ans = 64'h6B00000100000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3444539\n");
-    end
-    x = 64'hC7F22D8469F0C3B1;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC8222D8469F0C3B0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3445153\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h3FEFFDFFEFFFFFFF;
-    z = 64'hBF8007FFFF800000;
-    ans = 64'hBF8007FFFF800000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3445767\n");
-    end
-    x = 64'h4190000000000060;
-    y = 64'h4340000000000000;
-    z = 64'hBFD81177F4F07753;
-    ans = 64'h44E0000000000060;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3446381\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hB7EFDDFFFFFFFFFF;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3446995\n");
-    end
-    x = 64'hC8000001F7FFFFFF;
-    y = 64'hB7FE00000003FFFF;
-    z = 64'hBFB0000FFFFFFFFE;
-    ans = 64'h400D80033103FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3447609\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3448223\n");
-    end
-    x = 64'h43DFFC00000FFFFE;
-    y = 64'h3E6F7FFFFF7FFFFE;
-    z = 64'h8000000000000000;
-    ans = 64'h425F7C0FFF8FCFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3448837\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h7FE0000000000000;
-    z = 64'hBF101FFFFFF7FFFF;
-    ans = 64'hC00000203FFFFFF1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3449451\n");
-    end
-    x = 64'hAA50008000000000;
-    y = 64'hB7EFFFFF001FFFFE;
-    z = 64'hBFFFFFFFFFEFFE00;
-    ans = 64'hBFFFFFFFFFEFFE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3450065\n");
-    end
-    x = 64'h37FBFFFFFFEFFFFF;
-    y = 64'h7FE0000000000001;
-    z = 64'hC010000000000000;
-    ans = 64'h77EBFFFFFFF00001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3450679\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h800F7FFFFFFFFF80;
-    z = 64'h37B00000083FFFFF;
-    ans = 64'h37B00000083FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3451293\n");
-    end
-    x = 64'h402FFFC07FFFFFFE;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h400FBBFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3451907\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hC0FFFFFFFFF01FFE;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3452521\n");
-    end
-    x = 64'h000000000000007A;
-    y = 64'hC34B191A46C9F624;
-    z = 64'h41FFFFFFFFFDBFFE;
-    ans = 64'h41FFFFFFFFFDBFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3453135\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h7FF0000000000001;
-    z = 64'hBFE0000000000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3453749\n");
-    end
-    x = 64'hBFFFFFBFFFFFBFFF;
-    y = 64'hCF7FF000003FFFFF;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3454363\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h3FF2C214BD28AB14;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3454977\n");
-    end
-    x = 64'hC3400007FFFFFBFF;
-    y = 64'h3E10000000200400;
-    z = 64'hBFA0010010000000;
-    ans = 64'hC160000801201010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3455591\n");
-    end
-    x = 64'hC3CFEFFFFFEFFFFE;
-    y = 64'h8000000000000000;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3456205\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h402FFFF800000000;
-    z = 64'hBFFFFC01FFFFFFFE;
-    ans = 64'hBFFFFC01FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3456819\n");
-    end
-    x = 64'h41D00000F7FFFFFF;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h41900000001BFFFE;
-    ans = 64'h41900000001BFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3457433\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hBE6FFE000000FFFF;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3CA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3458047\n");
-    end
-    x = 64'h47E2000FFFFFFFFF;
-    y = 64'h5EEB8AC00B21E1F9;
-    z = 64'h8000000003FFFFFE;
-    ans = 64'h66DEFC3397462958;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3458661\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h8010000000000000;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3459275\n");
-    end
-    x = 64'h401F5D0E48FDF300;
-    y = 64'hC27FFFFDFFFFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3459889\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h402403B9376E4ABD;
-    ans = 64'h402403B9376E4ABD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3460503\n");
-    end
-    x = 64'hC7E0000000000102;
-    y = 64'h32CFFFFFFFFC07FF;
-    z = 64'h04CFFF7FFFFFFDFE;
-    ans = 64'hBABFFFFFFFFC0A03;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3461117\n");
-    end
-    x = 64'h41F911036CBF63B6;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3461731\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h2AAAFFFFFFFFFFFF;
-    z = 64'hDF0FDD09B53983F3;
-    ans = 64'hDF0FDD09B53983F3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3462345\n");
-    end
-    x = 64'hBEF001001FFFFFFF;
-    y = 64'hBCA0000000000001;
-    z = 64'hBDE07FFFFFFFFC00;
-    ans = 64'hBDE07FFFFFFEFBF0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3462959\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hC060000FFFFFFFF6;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h0080400FFFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3463573\n");
-    end
-    x = 64'hC3C01FFFFFEFFFFF;
-    y = 64'h40200000001FFFFD;
-    z = 64'h43F003FFFFFBFFFE;
-    ans = 64'hC37C0000143FFDFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3464187\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3464801\n");
-    end
-    x = 64'hBE656A583A6372FE;
-    y = 64'hB81FFFFFFFC20000;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3465415\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hBFD0000000000001;
-    z = 64'h3EF00101FFFFFFFF;
-    ans = 64'h3EF00101FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3466029\n");
-    end
-    x = 64'hC05D5279C4F75DDD;
-    y = 64'h410FBFFEFFFFFFFF;
-    z = 64'hBD90FF8000000000;
-    ans = 64'hC17D17D3E6D9A0F9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3466643\n");
-    end
-    x = 64'hC01FF0000FFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h4007F0000FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3467257\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hC7FFBFFFFFFFFFF8;
-    z = 64'h3F7FFFFFFFFFFFFF;
-    ans = 64'h3F7FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3467871\n");
-    end
-    x = 64'h3FD0000001C00000;
-    y = 64'hBFE0000000000000;
-    z = 64'hBA900000FFFFFFFF;
-    ans = 64'hBFC0000001C00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3468485\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h434C50942BB01F08;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h836C50942BB01F09;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3469099\n");
-    end
-    x = 64'hBFB000000807FFFF;
-    y = 64'h47EFF7FE00000000;
-    z = 64'hB7E07FFFFFFFBFFF;
-    ans = 64'hC7AFF7FE100BFAFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3469713\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h800FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3470327\n");
-    end
-    x = 64'h3FF001FFDFFFFFFE;
-    y = 64'h402EFFFFFFFFFC00;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000008;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3470941\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hBFF0000000000000;
-    z = 64'hB6E0000002200000;
-    ans = 64'hB6E0000002200000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3471555\n");
-    end
-    x = 64'hC1FF800001FFFFFE;
-    y = 64'h4400000001FFFFF8;
-    z = 64'hB81F8000000003FF;
-    ans = 64'hC60F800005EFFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3472169\n");
-    end
-    x = 64'hAE5F801FFFFFFFFF;
-    y = 64'hBFF0000000000001;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3472783\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h7FD00000000103FE;
-    z = 64'h3F900003FFFFDFFF;
-    ans = 64'hBFEF7FFFE00208FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3473397\n");
-    end
-    x = 64'h253FFFFE01FFFFFF;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hBFDF800007FFFFFF;
-    ans = 64'hBFDF800007FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3474011\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hC097F535A94B8768;
-    z = 64'h0000000000000000;
-    ans = 64'h00B7F535A94B8769;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3474625\n");
-    end
-    x = 64'hBFCFFFFFFF03FFFF;
-    y = 64'h7FFC04AA4A34A9A1;
-    z = 64'hB7E8A2BA0464A248;
-    ans = 64'h7FFC04AA4A34A9A1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3475239\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hC000000000000001;
-    z = 64'h8010000000000000;
-    ans = 64'h0010000000000004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3475853\n");
-    end
-    x = 64'h3FDFFEFFFFFFC000;
-    y = 64'hC1FFDFFFF8000000;
-    z = 64'h4010000000000001;
-    ans = 64'hC1EFDF00F7800040;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3476467\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h2162E1C38925382F;
-    ans = 64'h2162E1C38925382F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3477081\n");
-    end
-    x = 64'h41EFF7FFFEFFFFFE;
-    y = 64'hC00FFF7FFFFFFFFF;
-    z = 64'h4C40000007F7FFFE;
-    ans = 64'h4C40000007F7FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3477695\n");
-    end
-    x = 64'hC420000FFDFFFFFF;
-    y = 64'hC010000000000000;
-    z = 64'hBFD0000000000001;
-    ans = 64'h4440000FFDFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3478309\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h37EFFFFFFFFFEEFE;
-    z = 64'h802FFFFFFFFFFDFE;
-    ans = 64'h802FFFFFFFFFFDFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3478923\n");
-    end
-    x = 64'hBB9010000001FFFE;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h400FFFF80000003E;
-    ans = 64'h400FFFF80000003E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3479537\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hC26FFFFFFFBFFF80;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3480151\n");
-    end
-    x = 64'h3FBFFFFFFFFFF7FD;
-    y = 64'hB7FA36D046DE74F2;
-    z = 64'h422FFFFE00200000;
-    ans = 64'h422FFFFE00200000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3480765\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hC340000000000000;
-    z = 64'h8000000000000001;
-    ans = 64'h0360000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3481379\n");
-    end
-    x = 64'h43FFBFFFFEFFFFFF;
-    y = 64'h1C97F43A22A60B85;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3481993\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h002175F4C9217C07;
-    ans = 64'h0370000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3482607\n");
-    end
-    x = 64'hC13FDC0000000000;
-    y = 64'hC6E98960D74C89F6;
-    z = 64'h26F007FEFFFFFFFF;
-    ans = 64'h48396CA64A5A53DB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3483221\n");
-    end
-    x = 64'h380FFC000003FFFE;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCB00000FFE00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3483835\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'h41EB3544B5D48790;
-    z = 64'h43CFFFFFF7FFFEFF;
-    ans = 64'h43CFFFFFF7FFFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3484449\n");
-    end
-    x = 64'hC03000080000003F;
-    y = 64'hFFE0000000000001;
-    z = 64'h402007FFFDFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3485063\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hBF2F7FFFFFFBFFFF;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3485677\n");
-    end
-    x = 64'hC1EFFFFC07FFFFFF;
-    y = 64'h4EF8FD99B216C7A4;
-    z = 64'h47FFFFFFFFFF8010;
-    ans = 64'hD0F8FD9698A2F7CD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3486291\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3486905\n");
-    end
-    x = 64'h7FEA9C0EFE0A98BD;
-    y = 64'h403E000400000000;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3487519\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hFFF0000000000001;
-    z = 64'hB7E0005FFFFFFFFE;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3488133\n");
-    end
-    x = 64'h372FFFFBFFFFFFFF;
-    y = 64'h00200003FDFFFFFF;
-    z = 64'h43474A03BCE98E5F;
-    ans = 64'h43474A03BCE98E5F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3488747\n");
-    end
-    x = 64'h3C5BE00000000000;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3489361\n");
-    end
-    x = 64'h8010000000000001;
-    y = 64'hC0B7FFFFFFFFFFF7;
-    z = 64'h946000000001BFFE;
-    ans = 64'h946000000001BFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3489975\n");
-    end
-    x = 64'h43F3FFFFFFFFDFFE;
-    y = 64'h0000000000000000;
-    z = 64'hF4D00007FFF7FFFF;
-    ans = 64'hF4D00007FFF7FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3490589\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hC03FE00000FFFFFE;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3491203\n");
-    end
-    x = 64'h3FE506CBB5C9EF4A;
-    y = 64'hC34F7DFFFFFFFFFF;
-    z = 64'h380CC9555D83D483;
-    ans = 64'hC344B1601A376AED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3491817\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3492431\n");
-    end
-    x = 64'hC3DFFFFF80000002;
-    y = 64'h41C00000002007FF;
-    z = 64'h3FF0000000000000;
-    ans = 64'hC5AFFFFF80400FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3493045\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h0010000000000000;
-    z = 64'hC1EFFFFFF81FFFFE;
-    ans = 64'hC1EFFFFFF81FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3493659\n");
-    end
-    x = 64'hC00FFFFFE0000003;
-    y = 64'hC7E0000070000000;
-    z = 64'hBFFFE000000001FF;
-    ans = 64'h480000005FFFFF92;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3494273\n");
-    end
-    x = 64'h4C90FFFC00000000;
-    y = 64'h0010000000000001;
-    z = 64'h8010000000000000;
-    ans = 64'h0CB0FFFC00000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3494887\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h434FA2E02353B267;
-    z = 64'hBD91FFFFFFBFFFFF;
-    ans = 64'hBD91FFFFFFBFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3495501\n");
-    end
-    x = 64'h800FFFFFFFBFDFFF;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hC09FFFFFE0000003;
-    ans = 64'hC09FFFFFE0000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3496115\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h413FFFFDFFFFFF7F;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3496729\n");
-    end
-    x = 64'h400FFFFFFE000003;
-    y = 64'h47E3EFFFFFFFFFFE;
-    z = 64'hFFD2F1E7ED80838D;
-    ans = 64'hFFD2F1E7ED80838D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3497343\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h3CA0000000000001;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3497957\n");
-    end
-    x = 64'hC2AFFFFFFFFFFFE6;
-    y = 64'h401FFF8FFFFFFFFF;
-    z = 64'h3FE0000000000001;
-    ans = 64'hC2DFFF8FFFFFFFC5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3498571\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h3FA0FFFFFFFFFDFF;
-    ans = 64'h3FA0FFFFFFFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3499185\n");
-    end
-    x = 64'hDED45D2D699E6FBD;
-    y = 64'h3F9FFFE0001FFFFE;
-    z = 64'h3C0FFFFEFFFFFFF6;
-    ans = 64'hDE845D190C85634B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3499799\n");
-    end
-    x = 64'h3F9FFFEFFFFFFFFF;
-    y = 64'h3FD0000000000000;
-    z = 64'h8000000000000001;
-    ans = 64'h3F7FFFEFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3500413\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hC5D0010FFFFFFFFE;
-    z = 64'hC1C007FEFFFFFFFF;
-    ans = 64'hC1C007FEFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3501027\n");
-    end
-    x = 64'hC7EFFFFFFFFFFFAF;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h43DFFFF7FFFFFFFD;
-    ans = 64'hC7DFFFFFFFFFFFAE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3501641\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h3FDFFFE000000000;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3502255\n");
-    end
-    x = 64'h43C000001FFF7FFF;
-    y = 64'hC0AFFFFFF0000040;
-    z = 64'h3FCAC386871DE4A6;
-    ans = 64'hC480000017FF800F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3502869\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h3FE0000000000000;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3503483\n");
-    end
-    x = 64'h3EC80743205F2B82;
-    y = 64'h3FDF00000007FFFF;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FE00002E8E120EC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3504097\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h3FE0000000000001;
-    z = 64'hBFCFF3FFFFFFFFFF;
-    ans = 64'hBFCFF3FFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3504711\n");
-    end
-    x = 64'h6D70000007FFFFEF;
-    y = 64'hC22FFF00003FFFFE;
-    z = 64'h7FD00FFFFFDFFFFF;
-    ans = 64'h7FD00FFFFFDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3505325\n");
-    end
-    x = 64'h3FA000000400FFFF;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3505939\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h3FCF800001FFFFFE;
-    z = 64'hBCA0000FF8000000;
-    ans = 64'hBCA0000FF8000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3506553\n");
-    end
-    x = 64'h3970000000200000;
-    y = 64'h3FF0000000000001;
-    z = 64'h40700000000100FF;
-    ans = 64'h40700000000100FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3507167\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hC1FFFFFFFFFFCFFE;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3507781\n");
-    end
-    x = 64'hC3FFFFFFFF7FF7FF;
-    y = 64'h3D5DB9AE86D5D3FA;
-    z = 64'h43D00000000407FF;
-    ans = 64'h43D000000003CC8C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3508395\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3509009\n");
-    end
-    x = 64'h381000010000003E;
-    y = 64'h43FFFF000000003F;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CB007FFC07FFBFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3509623\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h4000000000000000;
-    z = 64'h48049FCD56F7E1F9;
-    ans = 64'h48049FCD56F7E1F9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3510237\n");
-    end
-    x = 64'h0010000400000400;
-    y = 64'hC80FE00000003FFE;
-    z = 64'h43D0000000001FFF;
-    ans = 64'h43D0000000001FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3510851\n");
-    end
-    x = 64'h3649AFC65D0A6F1A;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3511465\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h4024A534AC48D6E4;
-    z = 64'h3E7FFFFFFF7FE000;
-    ans = 64'h3E7FFFFFFF7FE000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3512079\n");
-    end
-    x = 64'hBFEFFFFFFFFF7FDE;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hC7EFFBFFFFFFFFEE;
-    ans = 64'hC7EFFBFFFFFFFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3512693\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h0020C022F6C81829;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3513307\n");
-    end
-    x = 64'hBD5FFFFFC0000040;
-    y = 64'hFFD0000037FFFFFF;
-    z = 64'hB7FFFF0000003FFF;
-    ans = 64'h7D40000017FFFFAF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3513921\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3514535\n");
-    end
-    x = 64'h0020800000000040;
-    y = 64'h855FFFFC00800000;
-    z = 64'h3CA0000000000000;
-    ans = 64'h3CA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3515149\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h7FDEF537F9C2304D;
-    ans = 64'h7FDEF537F9C2304D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3515763\n");
-    end
-    x = 64'h402FFFFFFFBFFDFF;
-    y = 64'h380E71F983F5560D;
-    z = 64'h40107FF7FFFFFFFF;
-    ans = 64'h40107FF7FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3516377\n");
-    end
-    x = 64'h38022398FCD2938A;
-    y = 64'h4340000000000001;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3516991\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h4063FFFFFF7FFFFF;
-    z = 64'hC34E00000000001F;
-    ans = 64'hC34E00000000001F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3517605\n");
-    end
-    x = 64'h6900040FFFFFFFFF;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h3CA0000820000000;
-    ans = 64'h6C60040FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3518219\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hBF40008200000000;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3518833\n");
-    end
-    x = 64'hE86000003FFFFFF7;
-    y = 64'hBFCFFFFFFFF003FE;
-    z = 64'hBF8FFFFEFFDFFFFE;
-    ans = 64'h684000003FF801F6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3519447\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h7FE0000000000001;
-    z = 64'h4000000000000000;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3520061\n");
-    end
-    x = 64'h3CA3B66E73907425;
-    y = 64'hC347B0AB22B11B1E;
-    z = 64'h0010000000000001;
-    ans = 64'hBFFD2FE85D912D4F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3520675\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hC1FFFFBBFFFFFFFF;
-    ans = 64'hC1FFFFBC007FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3521289\n");
-    end
-    x = 64'hC7E00000000003EF;
-    y = 64'hC0DFFFFFFFBFE000;
-    z = 64'h41EFFFFFFE03FFFF;
-    ans = 64'h48CFFFFFFFBFE7DE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3521903\n");
-    end
-    x = 64'hD8BEFFFFF7FFFFFF;
-    y = 64'h7FF0000000000000;
-    z = 64'h4340000000000001;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3522517\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h40300000003FEFFF;
-    z = 64'h3EC007DFFFFFFFFF;
-    ans = 64'h3EC007DFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3523131\n");
-    end
-    x = 64'h38DFFFFBFFFFFDFE;
-    y = 64'h7FF0000000000001;
-    z = 64'hC3FE5E4374175B59;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3523745\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h403FFFFEFDFFFFFF;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3524359\n");
-    end
-    x = 64'h403FFFFFEFEFFFFE;
-    y = 64'hBB2000080007FFFE;
-    z = 64'hBE2C76A7686DFB50;
-    ans = 64'hBE2C76A7686DFD50;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3524973\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h8000000000000000;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3525587\n");
-    end
-    x = 64'h4104000000FFFFFF;
-    y = 64'hC3C3FFFFFFFFFBFF;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hC4D90000013FFAFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3526201\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h8000000000000001;
-    z = 64'hC800000000001FFE;
-    ans = 64'hC800000000001FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3526815\n");
-    end
-    x = 64'hBCA3FFFFFF7FFFFE;
-    y = 64'h7CFFFFFFFFFFFF86;
-    z = 64'hC7E0000008007FFF;
-    ans = 64'hF9B3FFFFFF7FFFB2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3527429\n");
-    end
-    x = 64'h4050000000081FFF;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3528043\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hC27F800000080000;
-    z = 64'h400FFF000FFFFFFE;
-    ans = 64'h400FFF000FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3528657\n");
-    end
-    x = 64'h3CA0000400000800;
-    y = 64'h8010000000000000;
-    z = 64'h41F0900000000000;
-    ans = 64'h41F0900000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3529271\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h3E57FFFFFFFFF7FE;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3529885\n");
-    end
-    x = 64'hBFFFFFFFFFFFF7FE;
-    y = 64'hBFD00000021FFFFF;
-    z = 64'hC1CFFFBEFFFFFFFF;
-    ans = 64'hC1CFFFBEFFBFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3530499\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3531113\n");
-    end
-    x = 64'h40CFFFFFFE00003F;
-    y = 64'h3EAFBFFFFFFFFFF0;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3531727\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hBCA0000000000000;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3532341\n");
-    end
-    x = 64'h40D003FFBFFFFFFF;
-    y = 64'hC0196164645A61E5;
-    z = 64'h402B42415A9A50D4;
-    ans = 64'hC0F966E245E31218;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3532955\n");
-    end
-    x = 64'h41DD5E1041ECA9F1;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFC543DF7A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3533569\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hC780000006FFFFFF;
-    z = 64'h82E3CEE5E282FCA6;
-    ans = 64'h07B0000006FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3534183\n");
-    end
-    x = 64'h400FFFFF800FFFFF;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h43FFC00000000007;
-    ans = 64'h43FFC00000000007;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3534797\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h403FFFFC00000080;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hBCAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3535411\n");
-    end
-    x = 64'hE53FF80000008000;
-    y = 64'h40327D016FBE9017;
-    z = 64'h49194977C779FC34;
-    ans = 64'hE58278622F62EA67;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3536025\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3536639\n");
-    end
-    x = 64'hC1CFFFE000000001;
-    y = 64'h43F9C62BF671BF1C;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3537253\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h0000000000021FFF;
-    ans = 64'h0010000000021FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3537867\n");
-    end
-    x = 64'hC3D080003FFFFFFE;
-    y = 64'h7FFFFFFFFFFBF7FF;
-    z = 64'hC0BFF7FFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFBF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3538481\n");
-    end
-    x = 64'h402FF00000FFFFFF;
-    y = 64'hBFE0000000000001;
-    z = 64'h4000000000000000;
-    ans = 64'hC017F00001000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3539095\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h3E2000000008001E;
-    z = 64'hC623ABA49F8E6A01;
-    ans = 64'hC623ABA49F8E6A01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3539709\n");
-    end
-    x = 64'h41D000007FFFFFEF;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h385FFF8000FFFFFE;
-    ans = 64'hC1D000007FFFFFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3540323\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h43E03FFFFFC00000;
-    z = 64'hBCA0000000000000;
-    ans = 64'hBCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3540937\n");
-    end
-    x = 64'hB890000000000203;
-    y = 64'hBFFBFC0000000000;
-    z = 64'hDFB98E7EA50A7F54;
-    ans = 64'hDFB98E7EA50A7F54;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3541551\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hBFF0000000000001;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3542165\n");
-    end
-    x = 64'hB8001FFFFFFFFFDF;
-    y = 64'h3E03C923713BC58E;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3542779\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'hC1D000000080007F;
-    ans = 64'hC1D000000080007F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3543393\n");
-    end
-    x = 64'hBFDAE20492ABEECE;
-    y = 64'h000FFFFFFFE0001F;
-    z = 64'hC00C81C068E036FB;
-    ans = 64'hC00C81C068E036FB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3544007\n");
-    end
-    x = 64'hC02E97087858051B;
-    y = 64'hC000000000000000;
-    z = 64'h3FF0000000000001;
-    ans = 64'h403F97087858051B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3544621\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h3FEEFFFFFFF7FFFE;
-    z = 64'h3977FFFFF8000000;
-    ans = 64'h3977FFFFF8000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3545235\n");
-    end
-    x = 64'h841489E493F1E3FB;
-    y = 64'hC000000000000001;
-    z = 64'hB7FFFFFFF1FFFFFF;
-    ans = 64'hB7FFFFFFF1FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3545849\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hA4780952CC27292A;
-    z = 64'h8010000000000001;
-    ans = 64'h8010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3546463\n");
-    end
-    x = 64'h3C60000000FFFFF7;
-    y = 64'hC000000003FF7FFF;
-    z = 64'hC0140001FFFFFFFF;
-    ans = 64'hC0140001FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3547077\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hC010000000000000;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3CA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3547691\n");
-    end
-    x = 64'hB81FFFBFFBFFFFFF;
-    y = 64'h41DFFE0001FFFFFF;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC34FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3548305\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hC010000000000001;
-    z = 64'hC1C000080000007F;
-    ans = 64'hC1C000080000007F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3548919\n");
-    end
-    x = 64'h400007FFF0000000;
-    y = 64'h401FE00000000003;
-    z = 64'h3FB0000000001080;
-    ans = 64'h403007F7F0100012;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3549533\n");
-    end
-    x = 64'h3FF3FFFFFFFFFFFD;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'hC021FFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3550147\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hC01FFFFFE003FFFF;
-    z = 64'h3FC08A330A869AF2;
-    ans = 64'h3FC08A330A869AF2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3550761\n");
-    end
-    x = 64'h41DB6C4ECDBC587A;
-    y = 64'hC340000000000000;
-    z = 64'h3FDA48692615FFD5;
-    ans = 64'hC52B6C4ECDBC587A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3551375\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hC5E0000001000000;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h0610000000FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3551989\n");
-    end
-    x = 64'hF1FF80000000000E;
-    y = 64'hC3C0008000000001;
-    z = 64'hB6FFFFFBFFFFFFDF;
-    ans = 64'h75CF80FC00000010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3552603\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h037FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3553217\n");
-    end
-    x = 64'h8000002FFFFFFFFF;
-    y = 64'h56C3FFFEFFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3553831\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hFFE0000000000000;
-    z = 64'hFFE52EC42BD5246C;
-    ans = 64'hFFE52EC42BD5246C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3554445\n");
-    end
-    x = 64'h3AE000A000000000;
-    y = 64'hBFC9DD9C9FA6F045;
-    z = 64'hAC4FFFFFF800001E;
-    ans = 64'hBAB9DE9F47C52CCA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3555059\n");
-    end
-    x = 64'hB8000010000001FF;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h78000010000001FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3555673\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hC03FFFDFFFEFFFFF;
-    z = 64'hD8CFEFFFFDFFFFFE;
-    ans = 64'hD8CFEFFFFDFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3556287\n");
-    end
-    x = 64'h4F1FFEFFEFFFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hC03FFFFFC0000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3556901\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'h38100000007BFFFE;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3557515\n");
-    end
-    x = 64'hBFBA38B46A6BC45C;
-    y = 64'hB5700001FFEFFFFF;
-    z = 64'h0010000400001FFE;
-    ans = 64'h353A38B7B16818F3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3558129\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3558743\n");
-    end
-    x = 64'hC1FFFFFFFFFF000F;
-    y = 64'h401FF0000007FFFF;
-    z = 64'hC010000000000000;
-    ans = 64'hC22FF000000F008E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3559357\n");
-    end
-    x = 64'h801FFFFFFFFFFFFF;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hC1E0EEDC0A56584A;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3559971\n");
-    end
-    x = 64'hC3E0000000DFFFFF;
-    y = 64'hBFB004000001FFFF;
-    z = 64'h401EFDFFFFFFFFFF;
-    ans = 64'h43A0040000E237FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3560585\n");
-    end
-    x = 64'h3BDFFFFFFFFFFFFF;
-    y = 64'h0000000000000001;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3561199\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h3F10000010040000;
-    z = 64'hB80000000203FFFF;
-    ans = 64'hB80000000203FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3561813\n");
-    end
-    x = 64'hC756C2BB148137AE;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h47F1999FB520B400;
-    ans = 64'h47F1999FB520B400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3562427\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hFFDFFF00000007FF;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3563041\n");
-    end
-    x = 64'h3CAFFDFFFFFDFFFE;
-    y = 64'hC05FE0000000FFFF;
-    z = 64'hBFBFFBFFFEFFFFFE;
-    ans = 64'hBFBFFBFFFF0007F6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3563655\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h0010000000000001;
-    z = 64'h0000000000000000;
-    ans = 64'h8000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3564269\n");
-    end
-    x = 64'hA589D73A50255699;
-    y = 64'hBFBDFFFFFFFFFFEF;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3564883\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hB80000000000103F;
-    ans = 64'hB80000000000103F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3565497\n");
-    end
-    x = 64'h599A418CB6682652;
-    y = 64'h38185008F1338C4A;
-    z = 64'hFFD1FFFFFFFFFBFE;
-    ans = 64'hFFD1FFFFFFFFFBFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3566111\n");
-    end
-    x = 64'h401676FE6363B6AF;
-    y = 64'h3CA0000000000000;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3CCA76FE6363B6AF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3566725\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h40066A7122CE9B43;
-    z = 64'hBFFFFFBFFFFBFFFE;
-    ans = 64'hBFFFFFBFFFFBFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3567339\n");
-    end
-    x = 64'hB80D7AECC874C39B;
-    y = 64'h3CA0000000000001;
-    z = 64'h37E000080001FFFF;
-    ans = 64'h37E000080001FFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3567953\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h37F0000007FFE000;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3568567\n");
-    end
-    x = 64'h5800000007FFFEFF;
-    y = 64'h47F3EFFFFFFFFFFE;
-    z = 64'h251000040000003E;
-    ans = 64'h6003F00009F7FEBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3569181\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3569795\n");
-    end
-    x = 64'hC1E0000001FDFFFF;
-    y = 64'hC61EFFFFFFFFFFFB;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'h480F000003DC1FF9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3570409\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h3FD0000000000001;
-    z = 64'hD75001FFFFFFF7FE;
-    ans = 64'hD75001FFFFFFF7FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3571023\n");
-    end
-    x = 64'hB4500A9B355B9DA1;
-    y = 64'h434FDFFFFFFFFF00;
-    z = 64'h802A66CCDA332D0A;
-    ans = 64'hB7AFF521344C8306;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3571637\n");
-    end
-    x = 64'h47FFFFFFFFFFE000;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h47EFFFFFFFFFDFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3572251\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hC3F00000FBFFFFFF;
-    z = 64'hC020008000080000;
-    ans = 64'hC020008000080000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3572865\n");
-    end
-    x = 64'h40C00E9357F1C66A;
-    y = 64'h3FE0000000000000;
-    z = 64'h840000000008007F;
-    ans = 64'h40B00E9357F1C66A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3573479\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hBFC01BFFFFFFFFFE;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3574093\n");
-    end
-    x = 64'h4019103C1A2007AE;
-    y = 64'hC1E000000001DFFE;
-    z = 64'h7FEFFFFFFEDFFFFF;
-    ans = 64'h7FEFFFFFFEDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3574707\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3575321\n");
-    end
-    x = 64'hC010003FFDFFFFFE;
-    y = 64'h380F7FFFFFFFE000;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3575935\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h3FF0000000000000;
-    z = 64'hFFEB2A3DD30E39A1;
-    ans = 64'hFFEB2A3DD30E39A1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3576549\n");
-    end
-    x = 64'h3FFFFFE003FFFFFF;
-    y = 64'h43E5002C3E9728BF;
-    z = 64'hC1CFE0000001FFFE;
-    ans = 64'h43F500174106F3AF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3577163\n");
-    end
-    x = 64'hBFD000007FFF7FFE;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'hBFE000007FFF7FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3577777\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h3FD0000004FFFFFF;
-    z = 64'h37ED063ED7FADEC0;
-    ans = 64'h37ED063ED7FADEC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3578391\n");
-    end
-    x = 64'hBFDFFDFFFFFFDFFF;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'hC347ACB97EB17C3A;
-    ans = 64'hC347ACB97EB17C3A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3579005\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h40F00000007FBFFF;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3579619\n");
-    end
-    x = 64'hC1C00000017FFFFF;
-    y = 64'hC0301EFFFFFFFFFE;
-    z = 64'hC4AFFFFBFFFFFFFD;
-    ans = 64'hC4AFFFFBFFFFFBF5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3580233\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h4000000000000001;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3580847\n");
-    end
-    x = 64'hB6DFFB8000000000;
-    y = 64'hC05FFFFFFFFDFFC0;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3581461\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h4010002000000003;
-    ans = 64'h4010002000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3582075\n");
-    end
-    x = 64'hB7E0000000802000;
-    y = 64'hCB5007FFFFFFF800;
-    z = 64'h409FFFDFFFFBFFFF;
-    ans = 64'h4340080000805C10;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3582689\n");
-    end
-    x = 64'h3FE00000001FFFFD;
-    y = 64'h4010000000000001;
-    z = 64'h0000000000000000;
-    ans = 64'h40000000001FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3583303\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h37EFF00004000000;
-    z = 64'hC80001003FFFFFFE;
-    ans = 64'hC80001003FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3583917\n");
-    end
-    x = 64'hC007800000000000;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hC1CB8195F37757A9;
-    ans = 64'hC1CB8195FF3757A9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3584531\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h4010B67191C48B15;
-    z = 64'h4010000000000000;
-    ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3585145\n");
-    end
-    x = 64'h3835086F8A7930D6;
-    y = 64'h400F7BFFFFFFFFFF;
-    z = 64'h45AFFFFFFFFFFDFF;
-    ans = 64'h45AFFFFFFFFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3585759\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h4340000000000000;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3586373\n");
-    end
-    x = 64'hCEF000000207FFFF;
-    y = 64'hC05CDD77E0D1432A;
-    z = 64'hBFD0000000000001;
-    ans = 64'h4F5CDD77E47B60E0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3586987\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h403BFFFFFFFFFFBE;
-    ans = 64'h403BFFFFFFFFFFBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3587601\n");
-    end
-    x = 64'hB81E7FFFFFFFFFFF;
-    y = 64'h4D410000FFFFFFFE;
-    z = 64'hC3EFFFFFFF7FF7FF;
-    ans = 64'hC570340103FFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3588215\n");
-    end
-    x = 64'h1FE0FFBFFFFFFFFF;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3588829\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hC3CFFFE000007FFF;
-    ans = 64'hC3CFFFE000007FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3589443\n");
-    end
-    x = 64'hBFC391E68E64E4C7;
-    y = 64'h7FE0000000000001;
-    z = 64'h28E07F7FFFFFFFFE;
-    ans = 64'hFFB391E68E64E4C8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3590057\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h3FE11F532437EC3E;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3590671\n");
-    end
-    x = 64'h44A0000023FFFFFF;
-    y = 64'hC3C0010000080000;
-    z = 64'h8019FFFFFFFFFFFF;
-    ans = 64'hC8700100240A3FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3591285\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hC010000000000001;
-    ans = 64'hC027FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3591899\n");
-    end
-    x = 64'h402FFFFFFFFFFFEC;
-    y = 64'h380FFFFE00FFFFFF;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3592513\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h7FF0000000000001;
-    z = 64'h46E0000021000000;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3593127\n");
-    end
-    x = 64'h4020000100000000;
-    y = 64'h3D4FB80000000000;
-    z = 64'h38007FFFFFFFF7FF;
-    ans = 64'h3D7FB801FB800000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3593741\n");
-    end
-    x = 64'h43D017FFFFFFFFFE;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3594355\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hC0500003FFE00000;
-    z = 64'h448357C41790A530;
-    ans = 64'h448357C41790A530;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3594969\n");
-    end
-    x = 64'h7FCCADFDE13D2A89;
-    y = 64'h8000000000000000;
-    z = 64'hC00EFFFFFFFEFFFF;
-    ans = 64'hC00EFFFFFFFEFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3595583\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h3C6F000000000FFF;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h3FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3596197\n");
-    end
-    x = 64'hB816C47C77CD4FB9;
-    y = 64'h3CA0000000001001;
-    z = 64'h43FFFFFFFDFFFEFF;
-    ans = 64'h43FFFFFFFDFFFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3596811\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3597425\n");
-    end
-    x = 64'hB7F00005FFFFFFFF;
-    y = 64'h7FFFFFFFFFE0007F;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFE0007F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3598039\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h8010000000000000;
-    z = 64'hBFC0000000000000;
-    ans = 64'hBFC0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3598653\n");
-    end
-    x = 64'h1B400000000FFF7F;
-    y = 64'h3CAFFFFFFC00FFFE;
-    z = 64'hB80FFFFEFFFFFF7F;
-    ans = 64'hB80FFFFEFFFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3599267\n");
-    end
-    x = 64'hC3DC5B44CF32758F;
-    y = 64'h8010000000000001;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3599881\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hC03141D1BA830FA0;
-    z = 64'h432FFC0000010000;
-    ans = 64'h432FFC0000010000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3600495\n");
-    end
-    x = 64'hC7FFFDFFEFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h41DFFFFDFDFFFFFF;
-    ans = 64'h41DFFFFDFDFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3601109\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h41CFFFFFE000001E;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h3FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3601723\n");
-    end
-    x = 64'h37EFFFFFFFFFFBFF;
-    y = 64'h37EFFFDFFFFF7FFE;
-    z = 64'h43E0000000008040;
-    ans = 64'h43E0000000008040;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3602337\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hBCA0000000000001;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3602951\n");
-    end
-    x = 64'hBA5FFFFFF00007FE;
-    y = 64'h401100007FFFFFFF;
-    z = 64'h8010000000000000;
-    ans = 64'hBA810000778003FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3603565\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hFFFF9F277AF39F4A;
-    ans = 64'hFFFF9F277AF39F4A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3604179\n");
-    end
-    x = 64'h4340018000000000;
-    y = 64'h3FB01B3E7CDC5A25;
-    z = 64'h43FD6361F6FE7D6F;
-    ans = 64'h43FD6382308092DF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3604793\n");
-    end
-    x = 64'hC3DFFFFFFFFFEFDF;
-    y = 64'hBFD0000000000000;
-    z = 64'hC340000000000000;
-    ans = 64'h43BFDFFFFFFFEFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3605407\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hBFCF0A649CE7E379;
-    z = 64'hBFE07F0000000000;
-    ans = 64'hBFE07F0000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3606021\n");
-    end
-    x = 64'hB7F012DE7CF1AB19;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h47F000003FFFFF7F;
-    ans = 64'h47F000003FFFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3606635\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hFCA0000FBFFFFFFE;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000008;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3607249\n");
-    end
-    x = 64'hBFB6A48CB024F7A8;
-    y = 64'hC030000040100000;
-    z = 64'h52F88B314F472C55;
-    ans = 64'h52F88B314F472C55;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3607863\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hBFE0000000000000;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3608477\n");
-    end
-    x = 64'hCE7FFFEBFFFFFFFF;
-    y = 64'hBCAC4284F9FA3266;
-    z = 64'h8000000000000001;
-    ans = 64'h4B3C427350671629;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3609091\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hC03FFFFFFFFF1000;
-    ans = 64'hC03FFFFFFFFF1000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3609705\n");
-    end
-    x = 64'h4006C48B197B2BCB;
-    y = 64'h43DFF7FFFFFFBFFF;
-    z = 64'h92623F346F64078A;
-    ans = 64'h43F6BED9F6B49F76;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3610319\n");
-    end
-    x = 64'h3EE00000000BFFFE;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hC010000000000001;
-    ans = 64'hC010000200000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3610933\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h402FFFFEFFFFF7FF;
-    z = 64'hC1FFFEFFFFFFF800;
-    ans = 64'hC1FFFEFFFFFFF800;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3611547\n");
-    end
-    x = 64'hC0389D70C7422759;
-    y = 64'hBFF0000000000001;
-    z = 64'hC1E0001FFFFFFFFE;
-    ans = 64'hC1E0001FFCEC51E5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3612161\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h43FFFFEFFDFFFFFF;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3612775\n");
-    end
-    x = 64'h3FE8EEBA01E48447;
-    y = 64'hC2BFFFFFF800007F;
-    z = 64'h424AC7A4E57541D9;
-    ans = 64'hC2B8B92AB1DDEBA6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3613389\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3614003\n");
-    end
-    x = 64'hC01FFFC00000007E;
-    y = 64'hC1FFDFFFBFFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3614617\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hC000000000000001;
-    z = 64'hB7F9DEF92C81623D;
-    ans = 64'hB7F9DEF92C81623D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3615231\n");
-    end
-    x = 64'h401FFFFFFFDE0000;
-    y = 64'h43C0000000007FFC;
-    z = 64'hC1D1FFFFFFFFFFFB;
-    ans = 64'h43EFFFFFFFD5FFF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3615845\n");
-    end
-    x = 64'h2D50000000FFFFBE;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC00FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3616459\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hCA7FBFFFFFFF7FFF;
-    z = 64'h0010000000002000;
-    ans = 64'h0AAFBFFFFFFF7FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3617073\n");
-    end
-    x = 64'hC0607FFBFFFFFFFF;
-    y = 64'hC010000000000000;
-    z = 64'h3FFFFFCFFFFFFFFE;
-    ans = 64'h40808FFBE7FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3617687\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h43DFFFE003FFFFFF;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3618301\n");
-    end
-    x = 64'h4590000007FF7FFF;
-    y = 64'hC1C86A12F7EE0253;
-    z = 64'h43C10000007FFFFF;
-    ans = 64'hC7686A130422487D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3618915\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3619529\n");
-    end
-    x = 64'h402D80C8C9A07C22;
-    y = 64'h3FD001FFFC000000;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3620143\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hC340000000000000;
-    z = 64'h0F9FFFFFFF000010;
-    ans = 64'h0F9FFFFFFF000010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3620757\n");
-    end
-    x = 64'hBCAFFF80FFFFFFFF;
-    y = 64'hF4540CFEF492C4F9;
-    z = 64'h43DFFFDFF7FFFFFE;
-    ans = 64'h71140CAF60FEEA52;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3621371\n");
-    end
-    x = 64'hC8076B4F59C23E85;
-    y = 64'hC340000000000001;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'h4B576B4F59C23E86;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3621985\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hCA30000000000080;
-    z = 64'h3FCDFFFFFFFFFFFC;
-    ans = 64'h3FCDFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3622599\n");
-    end
-    x = 64'hC0E18338554B04B7;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h3EEFFFFFFEFDFFFF;
-    ans = 64'h44418338554B04B6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3623213\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hDC7FFFFC3FFFFFFE;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h1CAFFFFC3FFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3623827\n");
-    end
-    x = 64'h3D25024D4C68C3B0;
-    y = 64'h3F4FFFFFC00007FF;
-    z = 64'hBF260C1D68A1C2F7;
-    ans = 64'hBF260C1D68A1BDB6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3624441\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hFFE0000000000001;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3625055\n");
-    end
-    x = 64'h299FFFFFFFFFFA00;
-    y = 64'h241FFFFFFDFFFFF7;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3625669\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h381FFFFFDBFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3626283\n");
-    end
-    x = 64'h3C03D19D713896A0;
-    y = 64'h43D0000001FFF7FF;
-    z = 64'h40FFDFFFFFFFBFFF;
-    ans = 64'h40FFE009E8CE79D8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3626897\n");
-    end
-    x = 64'h755077FFFFFFFFFE;
-    y = 64'hFFF0000000000000;
-    z = 64'hBFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3627511\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'h55F901489896FD56;
-    z = 64'h3FC8AE7AC3754886;
-    ans = 64'h3FC8AE7AC3754886;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3628125\n");
-    end
-    x = 64'h3EAFFFFFDFF00000;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hBFFFFFFBFFFFFFFC;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3628739\n");
-    end
-    x = 64'h801FFFFFFFFFFFFE;
-    y = 64'hB5E0010200000000;
-    z = 64'h0010000000000000;
-    ans = 64'h0010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3629353\n");
-    end
-    x = 64'hC0DFFFFF80000001;
-    y = 64'h44CFFFFFFFF6FFFF;
-    z = 64'hC02FF25C504A2810;
-    ans = 64'hC5BFFFFF7FF70000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3629967\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h0000000000000000;
-    z = 64'hBCA0000000000000;
-    ans = 64'hBCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3630581\n");
-    end
-    x = 64'hBE2FFE0000000008;
-    y = 64'h43DFFFFFFFFF7FFE;
-    z = 64'h4340000000000001;
-    ans = 64'h433FFFF800800002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3631195\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h7FDFFFFFFFEFFFFC;
-    ans = 64'h7FDFFFFFFFEFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3631809\n");
-    end
-    x = 64'h4FCFE00000000002;
-    y = 64'hB7F000000000103F;
-    z = 64'hB8089029A0EB5FB8;
-    ans = 64'hC7CFE00000002060;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3632423\n");
-    end
-    x = 64'h402000007FFFFEFF;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3633037\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hBFEFFFFFFFC00010;
-    z = 64'h332FFFFFFFFC07FF;
-    ans = 64'h3C9FFFFFFFC00010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3633651\n");
-    end
-    x = 64'hC032000000000003;
-    y = 64'h0010000000000001;
-    z = 64'hBE5003FFFFFDFFFE;
-    ans = 64'hBE5003FFFFFDFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3634265\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h3FF000000FFFFFF7;
-    z = 64'h0000000000000001;
-    ans = 64'hBCA000000FFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3634879\n");
-    end
-    x = 64'hC01FFFF800000200;
-    y = 64'h401001FFFF7FFFFF;
-    z = 64'hF210000040FFFFFF;
-    ans = 64'hF210000040FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3635493\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'h8010000000000001;
-    ans = 64'h8010000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3636107\n");
-    end
-    x = 64'h00000081FFFFFFFF;
-    y = 64'hC7EFFFFFFF7EFFFF;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3636721\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h3CA0000000000001;
-    z = 64'hF7A0000080FFFFFE;
-    ans = 64'hF7A0000080FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3637335\n");
-    end
-    x = 64'hC02918C49CF43452;
-    y = 64'h7FFFFFFFFFFFFEFC;
-    z = 64'h402FFFFFFFE00080;
-    ans = 64'h7FFFFFFFFFFFFEFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3637949\n");
-    end
-    x = 64'h8020000C00000000;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3638563\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hC03FFFE00000001E;
-    z = 64'h41C007FFFFFFDFFE;
-    ans = 64'h41C007FFFFFFDFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3639177\n");
-    end
-    x = 64'hFFF400000000001E;
-    y = 64'h3FD0000000000000;
-    z = 64'h9749F8042A7828F1;
-    ans = 64'hFFFC00000000001E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3639791\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h37EFFFFF7FEFFFFF;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3640405\n");
-    end
-    x = 64'hBF0000EFFFFFFFFF;
-    y = 64'hC77FFFFFFFF5FFFE;
-    z = 64'hC2200003F7FFFFFF;
-    ans = 64'h469000EFFFFAFFB3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3641019\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'hBC8FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3641633\n");
-    end
-    x = 64'hC1FFFFFFFF0FFFFE;
-    y = 64'hB80FFFE0001FFFFF;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3642247\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h3FE0000000000000;
-    z = 64'hBFBFF7FFFF000000;
-    ans = 64'hBFBFF7FFFF000004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3642861\n");
-    end
-    x = 64'hBE2D7F50748E2E92;
-    y = 64'hB3A004000000003E;
-    z = 64'hBDD00000800FFFFF;
-    ans = 64'hBDD00000800FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3643475\n");
-    end
-    x = 64'h401FFFE000000004;
-    y = 64'h3FE0000000000001;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'h400FFFE000000005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3644089\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h47FFFFFC00001FFF;
-    z = 64'hBD77EABF70AF8DAD;
-    ans = 64'hC4AFFFFC00001FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3644703\n");
-    end
-    x = 64'h403FFF8002000000;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h324FFFFFFFF8000E;
-    ans = 64'h403FFF8001FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3645317\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h3FBFFFFFFFFBBFFE;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3645931\n");
-    end
-    x = 64'hEDCFFBFFFFFFFFBF;
-    y = 64'hC00FC02000000000;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'h6DEFBC27FBFFFFC0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3646545\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h3FF0000000000001;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3647159\n");
-    end
-    x = 64'h4E80C21A53CEB830;
-    y = 64'h3FAFFFFFFFDF7FFE;
-    z = 64'h4000000000000000;
-    ans = 64'h4E40C21A53BDB30C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3647773\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h403EFFFFFFFFFFFB;
-    ans = 64'h403EFFFFFFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3648387\n");
-    end
-    x = 64'hC0EC000080000000;
-    y = 64'hFFEFFFFF7FC00000;
-    z = 64'h3CA00000000003FB;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3649001\n");
-    end
-    x = 64'hC3FFC0001FFFFFFF;
-    y = 64'h4000000000000000;
-    z = 64'hBCA0000000000000;
-    ans = 64'hC40FC0001FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3649615\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h402FFBFFFFFFFFFF;
-    z = 64'hC1D66071D432CFE3;
-    ans = 64'hC1D66071D432CFE3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3650229\n");
-    end
-    x = 64'h3FC0000000100008;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hC00FFFFFFE000006;
-    ans = 64'hC00BFFFFFDFC0004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3650843\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hC3C00007FFFF8000;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3651457\n");
-    end
-    x = 64'h38163F4BCFE61288;
-    y = 64'h3FDFFFF001FFFFFE;
-    z = 64'hBF5FFF7FFFFFFFFB;
-    ans = 64'hBF5FFF7FFFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3652071\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h4010000000000000;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3652685\n");
-    end
-    x = 64'h801FFBFFFFFDFFFE;
-    y = 64'hBFDBA8444505653F;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3653299\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'hC00FDFFFFFF00000;
-    ans = 64'hC00FDFFFFFF00002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3653913\n");
-    end
-    x = 64'h7FFF00000000000F;
-    y = 64'h3FB400000000001F;
-    z = 64'hC03FFFFFFFDFFFF0;
-    ans = 64'h7FFF00000000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3654527\n");
-    end
-    x = 64'hBFD0080000000020;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h8010000000000001;
-    ans = 64'hC00008000000001F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3655141\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h41E0FFFFFFFFFFFA;
-    z = 64'hBFF26B5D87C2CB8D;
-    ans = 64'hBFF26B5DCBC2CB8D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3655755\n");
-    end
-    x = 64'h43C0020000400000;
-    y = 64'h4340000000000001;
-    z = 64'hC34DBA2051ED9A0F;
-    ans = 64'h4710020000400001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3656369\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h3FC000FFFFFFFF80;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3656983\n");
-    end
-    x = 64'hBFFFFFE400000000;
-    y = 64'hBFDBD54407F5B2BC;
-    z = 64'hC02FFFFFFFFDFFF0;
-    ans = 64'hC02E42AD45285D34;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3657597\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3658211\n");
-    end
-    x = 64'h3FB25318C481E7CE;
-    y = 64'h480B6030B392D965;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h47CF5A64272A6473;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3658825\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h7FE0000000000000;
-    z = 64'h3CA0FFF800000000;
-    ans = 64'hFC90000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3659439\n");
-    end
-    x = 64'hBC207E0000000000;
-    y = 64'hC021000000001FFF;
-    z = 64'h7FFD3A97BA6B9782;
-    ans = 64'h7FFD3A97BA6B9782;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3660053\n");
-    end
-    x = 64'h3FD00000007FFBFF;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h7FD00000007FFBFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3660667\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hC7E000008003FFFF;
-    z = 64'h403645F83349B39B;
-    ans = 64'h449000008003FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3661281\n");
-    end
-    x = 64'hC3EF14FFEB0F3D07;
-    y = 64'h7FF0000000000000;
-    z = 64'h801AD5E676A26F15;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3661895\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hBFDFE007FFFFFFFF;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3662509\n");
-    end
-    x = 64'hBFB45FC3AA5813AC;
-    y = 64'h37EFFFE000004000;
-    z = 64'hBEC0000007EFFFFE;
-    ans = 64'hBEC0000007EFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3663123\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3663737\n");
-    end
-    x = 64'h000FFFFBFFFFFFBE;
-    y = 64'h7FEBB7B174CBCB9B;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h400FB7AA86DF6DF5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3664351\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h001639C0ADB56178;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3664965\n");
-    end
-    x = 64'h4002EFFA98BD895F;
-    y = 64'h3FD0000000000FDF;
-    z = 64'hE5D04000000003FF;
-    ans = 64'hE5D04000000003FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3665579\n");
-    end
-    x = 64'hDB1D604C1DB49326;
-    y = 64'h8000000000000001;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3666193\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hBFFFFFFFFFFE000F;
-    z = 64'hD0D0000000017FFF;
-    ans = 64'hD0D0000000017FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3666807\n");
-    end
-    x = 64'hC010000001F00000;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'hBA469C50554556D4;
-    ans = 64'hBA469C50554556D4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3667421\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h3F29FEBD6B0F049C;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3668035\n");
-    end
-    x = 64'hBFE0FFFFFC000000;
-    y = 64'hC1C0001FFFDFFFFF;
-    z = 64'h7FD00040000007FF;
-    ans = 64'h7FD00040000007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3668649\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h8010000000000001;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3669263\n");
-    end
-    x = 64'hC1EC010F446540A4;
-    y = 64'hBAC6852416F9C589;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD000000000000A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3669877\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hF7C00000043FFFFE;
-    ans = 64'hF7C00000043FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3670491\n");
-    end
-    x = 64'hC2E2654CDB87DD48;
-    y = 64'hC02FFFFFFFFE7FFF;
-    z = 64'hB750040000000010;
-    ans = 64'h4322654CDB870088;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3671105\n");
-    end
-    x = 64'h3F7FFFFFFFF0001E;
-    y = 64'hBCA0000000000000;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3671719\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hC039C87DD7926BBE;
-    z = 64'h41F000041FFFFFFF;
-    ans = 64'h41F000041FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3672333\n");
-    end
-    x = 64'hB80FFFFFFFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h800000000007FBFE;
-    ans = 64'h34CFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3672947\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hBFE2000000000003;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3673561\n");
-    end
-    x = 64'h4880000000087FFE;
-    y = 64'hEA400800007FFFFE;
-    z = 64'hC345D14186A8EEB1;
-    ans = 64'hF2D008000088843C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3674175\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hBFD0000000000000;
-    z = 64'h4010000000000000;
-    ans = 64'h4010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3674789\n");
-    end
-    x = 64'hC00F800001000000;
-    y = 64'h4000080000000FFF;
-    z = 64'h3CA0000000000001;
-    ans = 64'hC01F8FC001009F7E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3675403\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hBFD0000000000001;
-    z = 64'hBAB000000000FF7E;
-    ans = 64'h3C7FFFFFFF000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3676017\n");
-    end
-    x = 64'h400FE01000000000;
-    y = 64'hBFEFFFFFDF000000;
-    z = 64'h27F0000000002000;
-    ans = 64'hC00FE00FDF20EF80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3676631\n");
-    end
-    x = 64'h3FB007FFFFFFFFDF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3677245\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hBA13FDFFFFFFFFFE;
-    z = 64'h000FFFFFFE200000;
-    ans = 64'h36C3FDFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3677859\n");
-    end
-    x = 64'h41D86E890469D30F;
-    y = 64'hBFE0000000000000;
-    z = 64'hC03205A669DCD5C0;
-    ans = 64'hC1C86E890D6CA644;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3678473\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h7FDF03FFFFFFFFFE;
-    z = 64'hBFF0000000000001;
-    ans = 64'hFC8F03FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3679087\n");
-    end
-    x = 64'h7FE00077FFFFFFFE;
-    y = 64'h40E000001000001E;
-    z = 64'hBFD4FFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3679701\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'h4000000000000001;
-    ans = 64'h4000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3680315\n");
-    end
-    x = 64'h4800DF1F660F56AF;
-    y = 64'hDE3FFFFFFFFFB000;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'hE650DF1F660F2C81;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3680929\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hBFF0000000000000;
-    z = 64'h3E59A41A8D3F0D0E;
-    ans = 64'h3E59A41A8F3F0D0E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3681543\n");
-    end
-    x = 64'h31DC2BE698BED132;
-    y = 64'h3FA0000400000001;
-    z = 64'hC03FFF8001FFFFFF;
-    ans = 64'hC03FFF8001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3682157\n");
-    end
-    x = 64'hC0A31FC8DABA02AD;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h43500000000004C7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3682771\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h47E943885C8C6553;
-    z = 64'hC1FEE2CEB74B7C2D;
-    ans = 64'hC49943885C8C6D0C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3683385\n");
-    end
-    x = 64'h42C9F7BB6D642AEB;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h7FF01D9CEB412063;
-    ans = 64'h7FF81D9CEB412063;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3683999\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hBFD12DBE8A52106B;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3684613\n");
-    end
-    x = 64'hBFADA801A13F62D4;
-    y = 64'h402FDFFFFFFFEFFF;
-    z = 64'h43F00001FFFF8000;
-    ans = 64'h43F00001FFFF8000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3685227\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3685841\n");
-    end
-    x = 64'h3FC0000000800080;
-    y = 64'hC7E0000FFFF00000;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'hC7B0001000700100;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3686455\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h41DFFFFFFF7FFEFF;
-    ans = 64'h41DFFFFFFF7FFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3687069\n");
-    end
-    x = 64'h6CD0010003FFFFFF;
-    y = 64'hC1E000000FFFFFFF;
-    z = 64'hB5A0003FFFFBFFFF;
-    ans = 64'hEEC0010014010002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3687683\n");
-    end
-    x = 64'hB810FFFFBFFFFFFF;
-    y = 64'hC010000000000001;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h401FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3688297\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hC3EFC04000000000;
-    z = 64'h43EFFFBFFFFFFF7F;
-    ans = 64'h43EFFFBFFFFFFF80;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3688911\n");
-    end
-    x = 64'h99B00008000FFFFE;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hBE4FF80000007FFF;
-    ans = 64'hBE4FF80000007FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3689525\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hC451238B3FAD72A9;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'h410123873FAD72A9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3690139\n");
-    end
-    x = 64'h3FEB03EBAD17DB6E;
-    y = 64'h434FFFFD7FFFFFFF;
-    z = 64'hC2951E9EDCF540CE;
-    ans = 64'h434B0145BCEDD33F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3690753\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hC340000000000001;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3691367\n");
-    end
-    x = 64'h0005E0458A43FBDB;
-    y = 64'h7FDFFFBFFFFFFFFF;
-    z = 64'h0000000000000000;
-    ans = 64'h3FE780E726E39D4B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3691981\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h3FF0000002000003;
-    ans = 64'h4008000001000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3692595\n");
-    end
-    x = 64'h3FF0000000000043;
-    y = 64'h3FFD92E157246295;
-    z = 64'h00205FFFFFFFFFFF;
-    ans = 64'h3FFD92E157246311;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3693209\n");
-    end
-    x = 64'hC2DFFFFFBFF7FFFF;
-    y = 64'hFFE0000000000000;
-    z = 64'h4010000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3693823\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h47E02D7CE2B31E42;
-    z = 64'h3FDFFFFEFFFFFFFF;
-    ans = 64'hC4902D7CE2B31E42;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3694437\n");
-    end
-    x = 64'h4AD0000000010400;
-    y = 64'hFFE0000000000001;
-    z = 64'hC01FFFFFFFFFFB80;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3695051\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'h35A00080FFFFFFFF;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3695665\n");
-    end
-    x = 64'hBCAFFFFFE00001FF;
-    y = 64'h3283FE0000000000;
-    z = 64'hC02F7FFFFFFFFEFF;
-    ans = 64'hC02F7FFFFFFFFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3696279\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hFFF0000000000000;
-    z = 64'h3FE0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3696893\n");
-    end
-    x = 64'h43EFFFFDFFFDFFFF;
-    y = 64'hBFBFFFFFE0000003;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3697507\n");
-    end
-    x = 64'hBCA0000000000000;
-    y = 64'hFFF0000000000001;
-    z = 64'h43DBFFFFFFFFFFF7;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3698121\n");
-    end
-    x = 64'h3FC0000203FFFFFE;
-    y = 64'h4398F59E6CA7D49A;
-    z = 64'hBF9FF3DF6A07BBD1;
-    ans = 64'h4368F5A1919909C7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3698735\n");
-    end
-    x = 64'hFFFFFEFFFFFBFFFE;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h4000000000000001;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3699349\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h001000004000007F;
-    z = 64'h41C007FFFFEFFFFF;
-    ans = 64'h41C007FFFFEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3699963\n");
-    end
-    x = 64'hAD45032AE4153B5D;
-    y = 64'h0000000000000000;
-    z = 64'h3FDFFBFFBFFFFFFF;
-    ans = 64'h3FDFFBFFBFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3700577\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hC0A0000001FFFFEF;
-    z = 64'hBCA0000000000001;
-    ans = 64'h3D4FFC0003FFFFE0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3701191\n");
-    end
-    x = 64'hFFE01FFFDFFFFFFF;
-    y = 64'hB80007FFFFFFFFF7;
-    z = 64'hBFE4001FFFFFFFFE;
-    ans = 64'h77F0280FDFEFFFF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3701805\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3702419\n");
-    end
-    x = 64'hC7E00000F7FFFFFF;
-    y = 64'h3E22A58881822F6B;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3703033\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h0010000000000000;
-    z = 64'h05CF952FB7C9E1F0;
-    ans = 64'h05CF952FB7C9E1F0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3703647\n");
-    end
-    x = 64'h3FFFFE0000FFFFFF;
-    y = 64'h35503FFFFFFFFFFE;
-    z = 64'hC020000000300000;
-    ans = 64'hC020000000300000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3704261\n");
-    end
-    x = 64'h47EF01BF46D247DB;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h3FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3704875\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h002BFFFFFFFFFFFB;
-    z = 64'hBFC0000100000002;
-    ans = 64'hBFC0000100000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3705489\n");
-    end
-    x = 64'h400FFFF000002000;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hBE300C0000000000;
-    ans = 64'hBE300C0000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3706103\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h41EF00007FFFFFFE;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'hBE9F000080000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3706717\n");
-    end
-    x = 64'h3E300000001FE000;
-    y = 64'hC030000008000000;
-    z = 64'h40CFFFDFFFFFFFF7;
-    ans = 64'h40CFFFDFFFFF7FF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3707331\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3707945\n");
-    end
-    x = 64'h5AE01000000000FF;
-    y = 64'hB7E000000000000B;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hD2D010000000010A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3708559\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'hBF600010003FFFFF;
-    ans = 64'hBF600010003FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3709173\n");
-    end
-    x = 64'h3FC0100000001000;
-    y = 64'h3FBFFDFFFFFFFFFB;
-    z = 64'h3F68007FFFFFFFFF;
-    ans = 64'h3F930F0F00000FFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3709787\n");
-    end
-    x = 64'hBFA0000000100003;
-    y = 64'h3FD0000000000001;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h3FEFBFFFFFFFBFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3710401\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h483000000FFFDFFF;
-    z = 64'hC1F2000000000008;
-    ans = 64'hC4E000000FFFE024;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3711015\n");
-    end
-    x = 64'hFFFE0A678C624F99;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'h44A36355884BDF32;
-    ans = 64'hFFFE0A678C624F99;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3711629\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h7FF03FC000000000;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h7FF83FC000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3712243\n");
-    end
-    x = 64'h4194827E2F7BD16C;
-    y = 64'hC90FFFFFFFFFE800;
-    z = 64'hC3DF000000000008;
-    ans = 64'hCAB4827E2F7BC20A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3712857\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h3FE0000000000001;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'hBC90000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3713471\n");
-    end
-    x = 64'hC040003FEFFFFFFF;
-    y = 64'h3FDFFFFFFFFF8000;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000008;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3714085\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'hBFF0400000000400;
-    ans = 64'hBFF0400000000401;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3714699\n");
-    end
-    x = 64'h38000000000005FF;
-    y = 64'hFFEFFFF7FFFFFFF7;
-    z = 64'hC6C0000120000000;
-    ans = 64'hF7FFFFF800000BF5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3715313\n");
-    end
-    x = 64'h802000000001FFF7;
-    y = 64'h3FF0000000000000;
-    z = 64'h3FE0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3715927\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hC02E0D532183CA7C;
-    z = 64'h3FCD7D34563A15FD;
-    ans = 64'h3FCD7D34563A1639;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3716541\n");
-    end
-    x = 64'hEB5FFFFFDFBFFFFF;
-    y = 64'h3FF0000000000001;
-    z = 64'h409CBF6F4C076C92;
-    ans = 64'hEB5FFFFFDFC00001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3717155\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h000FFFFFC000001E;
-    z = 64'h8000000000000000;
-    ans = 64'h8000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3717769\n");
-    end
-    x = 64'hBFBFDFFFFFFBFFFF;
-    y = 64'h41DFFFFFF0010000;
-    z = 64'hE69FFFBFFEFFFFFF;
-    ans = 64'hE69FFFBFFEFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3718383\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h4000000000000000;
-    z = 64'h0010000000000000;
-    ans = 64'hBCB0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3718997\n");
-    end
-    x = 64'hC0D000000007FDFF;
-    y = 64'h41D00000FFFFF7FE;
-    z = 64'hC010000000000001;
-    ans = 64'hC2B000010007F9FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3719611\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h4000000000000001;
-    z = 64'hB84FBFFFFFFFFFFF;
-    ans = 64'hBCB0000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3720225\n");
-    end
-    x = 64'h3F8000000001FFFA;
-    y = 64'hFFEFFC000000001F;
-    z = 64'h50A000000001E000;
-    ans = 64'hFF7FFC000003FF93;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3720839\n");
-    end
-    x = 64'h40E0240000000000;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h3FD0000000000001;
-    ans = 64'h41002401FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3721453\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h802000003F7FFFFE;
-    z = 64'h38DFFFFFFFBFC000;
-    ans = 64'h38DFFFFFFFBFC000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3722067\n");
-    end
-    x = 64'h4378DAD7F8CB6D2E;
-    y = 64'h4010000000000000;
-    z = 64'hBFB007FFFFFEFFFF;
-    ans = 64'h4398DAD7F8CB6D2E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3722681\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h43EFFFE7FFFFFFFF;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3723295\n");
-    end
-    x = 64'hB7FFFFFFFFFFF8FF;
-    y = 64'hC3E4000000010000;
-    z = 64'h36EB61110674A849;
-    ans = 64'h3BF400000000FB9F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3723909\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h0000000000000001;
-    ans = 64'hBCD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3724523\n");
-    end
-    x = 64'h400FFFFFE0000080;
-    y = 64'h4F6FFFFFF0000000;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'h4F8FFFFFD0000090;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3725137\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h4340000000000000;
-    z = 64'hB9F00040007FFFFF;
-    ans = 64'hBFF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3725751\n");
-    end
-    x = 64'h480DFFEFFFFFFFFF;
-    y = 64'hBFCFFFEFFFFFF800;
-    z = 64'h3EA00000003FDFFF;
-    ans = 64'hC7EDFFE10007F87F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3726365\n");
-    end
-    x = 64'hB800000001FFFDFF;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h3CAFFFFEFFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3726979\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h1B9FFFFFE000FFFF;
-    z = 64'h3FEFEFFFBFFFFFFE;
-    ans = 64'h3FEFEFFFBFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3727593\n");
-    end
-    x = 64'hBF7FFFFFFBFEFFFE;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h403636BB565E6ADF;
-    ans = 64'hC2DFFFFFFBFEFA6E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3728207\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h3FB00001FFFC0000;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3728821\n");
-    end
-    x = 64'hFFEF9571FF100553;
-    y = 64'hBE7FFFFE03FFFFFF;
-    z = 64'hBFBFFFFBFF000000;
-    ans = 64'h7E7F957009AB93A1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3729435\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h7FE0000000000001;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3730049\n");
-    end
-    x = 64'hB81FFFFF8003FFFE;
-    y = 64'h400020001FFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3730663\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h9F80000003FFFFEE;
-    ans = 64'hFCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3731277\n");
-    end
-    x = 64'hC15800000000003E;
-    y = 64'h4EE09FFFFFFFFFFF;
-    z = 64'hBFCFFFFFFFFFFF7F;
-    ans = 64'hD048F0000000003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3731891\n");
-    end
-    x = 64'hC770007FFFFFFFEF;
-    y = 64'h7FF0000000000001;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3732505\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h7FDA7310ABEAE84F;
-    z = 64'h48A73ACD31EA4F8E;
-    ans = 64'hFC8A7310ABEAE851;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3733119\n");
-    end
-    x = 64'hC0D60CA21F4AD012;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'hBFD4DCE5D90DAA50;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3733733\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h401FF7FFFFFFFDFF;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3734347\n");
-    end
-    x = 64'h477FFFF7FFFFBFFF;
-    y = 64'h41D00200000FFFFF;
-    z = 64'hBFBFFFFFFFFFFFD8;
-    ans = 64'h496001FBFF8FDFF6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3734961\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h8000000000000000;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3735575\n");
-    end
-    x = 64'h3F10000003BFFFFE;
-    y = 64'h3E1FFFFFFFFFFFFF;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFEFFFFFFFFFFC00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3736189\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hC03B09EA7C43FEA2;
-    ans = 64'hC03B09EA7C43FEA2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3736803\n");
-    end
-    x = 64'hC1EFFFBFFFFFFFFD;
-    y = 64'h7FFFFEFFFFFFFFFA;
-    z = 64'h000FFFC07FFFFFFF;
-    ans = 64'h7FFFFEFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3737417\n");
-    end
-    x = 64'h779C6B30A6ACCE58;
-    y = 64'h8010000000000000;
-    z = 64'h0010000000000000;
-    ans = 64'hB7BC6B30A6ACCE58;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3738031\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h3FBD242FF9F7C369;
-    z = 64'h403E470AB2DD2D1D;
-    ans = 64'h403E470AB2DD2D1D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3738645\n");
-    end
-    x = 64'h380EFFFFFFFFFFFD;
-    y = 64'h8010000000000001;
-    z = 64'hBFA501B829A23C23;
-    ans = 64'hBFA501B829A23C23;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3739259\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h47FFFC00003FFFFF;
-    z = 64'h4340000000000000;
-    ans = 64'hC4AFFBFFC0400001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3739873\n");
-    end
-    x = 64'h8015D7ABA4BF48ED;
-    y = 64'h3F1FFFFFF7FFFFFE;
-    z = 64'h7FEE2DBEE5C2D97E;
-    ans = 64'h7FEE2DBEE5C2D97E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3740487\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3741101\n");
-    end
-    x = 64'h3FE00001FFFC0000;
-    y = 64'h3FCB2596D8FD2EB9;
-    z = 64'hBFE0000000000001;
-    ans = 64'hBFD936997095AFE5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3741715\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hBCA0000000000001;
-    z = 64'h4073FFFFEFFFFFFE;
-    ans = 64'h4073FFFFEFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3742329\n");
-    end
-    x = 64'hD2F0B2C9A70221FF;
-    y = 64'h43E199DDC5665EB1;
-    z = 64'hFFE84B6CAA717C29;
-    ans = 64'hFFE84B6CAA717C29;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3742943\n");
-    end
-    x = 64'hD94FF81000000000;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h0000000000000001;
-    ans = 64'h560FF80FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3743557\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h400FFFFFF7FFFDFF;
-    z = 64'hB4DFEFFFFFFFFF7F;
-    ans = 64'hBCBFFFFFF7FFFE01;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3744171\n");
-    end
-    x = 64'hC52FFEFFFFFFBFFE;
-    y = 64'hBFD0000000000000;
-    z = 64'hBFA0000FFFFFFE00;
-    ans = 64'h450FFEFFFFFFBFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3744785\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hBFFB106850049EF2;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3745399\n");
-    end
-    x = 64'h43429BCA2DC4DCB8;
-    y = 64'h29FDFFFFFFFFF800;
-    z = 64'h4340200080000000;
-    ans = 64'h4340200080000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3746013\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3746627\n");
-    end
-    x = 64'hC250FFFFFFFFFFFE;
-    y = 64'hC14A4CD328768347;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'h43ABF1A05AFDEB78;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3747241\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hBFE0000000000000;
-    z = 64'h480FC01FFFFFFFFF;
-    ans = 64'h480FC01FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3747855\n");
-    end
-    x = 64'h3FD200000001FFFF;
-    y = 64'h3F80000400800000;
-    z = 64'hB810FFFFFFFFFFFC;
-    ans = 64'h3F62000480920000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3748469\n");
-    end
-    x = 64'hB810100000000000;
-    y = 64'hBFE0000000000001;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3749083\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h41DFFFFFFFFF0003;
-    z = 64'h3CA0001FFFFFFFFB;
-    ans = 64'hBE8FFFFFFFBEFF85;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3749697\n");
-    end
-    x = 64'hFFF20001FFFFFFFF;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hBFBBFFFFFFFFFBFF;
-    ans = 64'hFFFA0001FFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3750311\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hBCAFF00003FFFFFF;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3750925\n");
-    end
-    x = 64'h43DFFFFFFF7FFFC0;
-    y = 64'h231F2EC23DED0C48;
-    z = 64'h518EFFFFC0000000;
-    ans = 64'h518EFFFFC0000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3751539\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hBFF0000000000001;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3752153\n");
-    end
-    x = 64'hC08FFFFEE0000000;
-    y = 64'h43FE83C87C2780E4;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hC49E83C769857487;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3752767\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'hBFE90AAFA45FC660;
-    ans = 64'hBFE90AAFA45FC65E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3753381\n");
-    end
-    x = 64'hC1F97E13BBA0D54D;
-    y = 64'h434FFF80000000FF;
-    z = 64'h41E200003FFFFFFF;
-    ans = 64'hC5597DADC351E795;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3753995\n");
-    end
-    x = 64'h3FC3FF7FFFFFFFFF;
-    y = 64'hC000000000000000;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3754609\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h41E00000000000FD;
-    z = 64'h748FFFFFFDF7FFFF;
-    ans = 64'h748FFFFFFDF7FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3755223\n");
-    end
-    x = 64'h37FBBEB4E97ED446;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h7FE9E49884FB358B;
-    ans = 64'h7FE9E49884FB358B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3755837\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hC7FFFFFFF0001FFF;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h44AFFFFFF0002001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3756451\n");
-    end
-    x = 64'hC3E000000207FFFF;
-    y = 64'h3FE0000000004003;
-    z = 64'hC1D200000000000F;
-    ans = 64'hC3D00000021A4002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3757065\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hC010000000000000;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hC00FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3757679\n");
-    end
-    x = 64'hC1E000000000DFFF;
-    y = 64'h47EFFFE7FFFFFFFF;
-    z = 64'hBCA0000000000000;
-    ans = 64'hC9DFFFE80001BFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3758293\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'hC180000000001003;
-    ans = 64'hC180000000001003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3758907\n");
-    end
-    x = 64'h3F20407FFFFFFFFF;
-    y = 64'hFFD01FFFFFFFFFFE;
-    z = 64'hC1DFFFFFFE00001F;
-    ans = 64'hFF006100FFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3759521\n");
-    end
-    x = 64'h3AD0000000001FDF;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3760135\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hC1D0000FFFFFFFFD;
-    z = 64'h001022851DC3F35C;
-    ans = 64'h3E80000FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3760749\n");
-    end
-    x = 64'hB7EFFFFFFDFFFFE0;
-    y = 64'hC340000000000001;
-    z = 64'h43F103FFFFFFFFFE;
-    ans = 64'h43F103FFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3761363\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hC80C020548AB0BD7;
-    z = 64'h3FF0000000000000;
-    ans = 64'h44BC020548AB0BD9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3761977\n");
-    end
-    x = 64'h8A7EFFFFFFFFFFF7;
-    y = 64'h42620001FFFFFFFF;
-    z = 64'hC1D000001000FFFE;
-    ans = 64'hC1D000001000FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3762591\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hC000000000000000;
-    ans = 64'hB980000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3763205\n");
-    end
-    x = 64'h7FFFFE00003FFFFE;
-    y = 64'h3FB0000000107FFE;
-    z = 64'h8010000000000001;
-    ans = 64'h7FFFFE00003FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3763819\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hFFE0000000000001;
-    z = 64'h47EF19603D95F25F;
-    ans = 64'h7C90000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3764433\n");
-    end
-    x = 64'h434FC6B058E8DB04;
-    y = 64'hC7F0001F7FFFFFFE;
-    z = 64'h09BFFFFFFFFEFEFF;
-    ans = 64'hCB4FC6EEE8140A0A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3765047\n");
-    end
-    x = 64'hBD2000107FFFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'hC340000000000001;
-    ans = 64'h7D2000107FFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3765661\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h7FDFFFFFFFFFEFDF;
-    z = 64'hC00FFF01FFFFFFFE;
-    ans = 64'hFC8FFFFFFFFFEFE1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3766275\n");
-    end
-    x = 64'hC1EFF8000000000F;
-    y = 64'hFFF0000000000000;
-    z = 64'h403E18E7F4D1673B;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3766889\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'h5D80000001003FFF;
-    z = 64'h3FE0000000000001;
-    ans = 64'hDA30000001004000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3767503\n");
-    end
-    x = 64'h7FE433DE65AD5CF1;
-    y = 64'hBFB00000004001FF;
-    z = 64'h7FF0000008000001;
-    ans = 64'h7FF8000008000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3768117\n");
-    end
-    x = 64'hBCA0000000000001;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hBFF0000000000001;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3768731\n");
-    end
-    x = 64'hFE4FF0FFFFFFFFFE;
-    y = 64'hBCA0000040003FFE;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h7AFFF1007FC47FBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3769345\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h0000000000000000;
-    z = 64'hC3CFEFFF7FFFFFFF;
-    ans = 64'hC3CFEFFF7FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3769959\n");
-    end
-    x = 64'hC02000003FFFFFFE;
-    y = 64'h05300005FFFFFFFF;
-    z = 64'hC0810000007FFFFE;
-    ans = 64'hC0810000007FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3770573\n");
-    end
-    x = 64'hC01FFE00000001FF;
-    y = 64'h0000000000000001;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hC01FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3771187\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hDADFFFFFFFFFFFF8;
-    z = 64'hC3CFDFFFFFFBFFFF;
-    ans = 64'h579FFFFFFFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3771801\n");
-    end
-    x = 64'h0020000000002080;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h3F0FFFFFFC080000;
-    ans = 64'h3F0FFFFFFC080000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3772415\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hC7F0000000001FFC;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h44B0000000001FFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3773029\n");
-    end
-    x = 64'hC3F4695058A6C40E;
-    y = 64'h4040080000000000;
-    z = 64'hB83FFFFDFFFFFFBE;
-    ans = 64'hC444738500D31770;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3773643\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h0010000000000001;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3774257\n");
-    end
-    x = 64'hC1F00000077FFFFE;
-    y = 64'hAB2000800000007F;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3774871\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hFFF3EC28CD007481;
-    ans = 64'hFFFBEC28CD007481;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3775485\n");
-    end
-    x = 64'h3FFC94ABE6867525;
-    y = 64'hC67E87B31ABFDBF0;
-    z = 64'h4012000FFFFFFFFF;
-    ans = 64'hC68B449454D84E0E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3776099\n");
-    end
-    x = 64'hFFD6F486F2DE1EE8;
-    y = 64'h3CA0000000000000;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'hFC86F486F2DE1EE8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3776713\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hBFCD146D2EEB9817;
-    z = 64'h43E00040007FFFFF;
-    ans = 64'h43E00040007FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3777327\n");
-    end
-    x = 64'hC80FF7FFFF7FFFFF;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h43FFFFFFFFE001FE;
-    ans = 64'hC4CFF6FFFF8000FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3777941\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hC032000000000004;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CF3000000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3778555\n");
-    end
-    x = 64'h4060001FBFFFFFFF;
-    y = 64'hC00F8CABD8D44234;
-    z = 64'h342DFF7FFFFFFFFF;
-    ans = 64'hC07F8CEA73F94477;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3779169\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h3FD0000000000000;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3779783\n");
-    end
-    x = 64'h402BFFFFFFFFFFFF;
-    y = 64'hC34F36F54B2B6FAA;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3780397\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hBFBFFFFFF800000E;
-    ans = 64'hBFBFFFFFF8000016;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3781011\n");
-    end
-    x = 64'h3FFFEFFFFFFFFFEF;
-    y = 64'hB7F0000FFC000000;
-    z = 64'hB73003FFFFFFF000;
-    ans = 64'hB7FFF1202803FFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3781625\n");
-    end
-    x = 64'h0023A4E6A0757395;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hC000000000000000;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3782239\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h3FF8E39EA08CCCC9;
-    z = 64'h3810000000BFFFFF;
-    ans = 64'hBCB8E39EA08CCCC8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3782853\n");
-    end
-    x = 64'h47DFFFFFFFFFFDBF;
-    y = 64'h3FE0000000000001;
-    z = 64'hC3EFFFE000001000;
-    ans = 64'h47CFFFFFFFFFFDC1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3783467\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hCD9C9445CD63D125;
-    z = 64'h3CA0000000000000;
-    ans = 64'h4A5C9445CD63D124;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3784081\n");
-    end
-    x = 64'hC02F7FFFEFFFFFFF;
-    y = 64'hC03FFBFFFFFFFFEF;
-    z = 64'hBCAFFFFFFFC3FFFE;
-    ans = 64'h407F7C0FF001FFEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3784695\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hBFD0000000000000;
-    ans = 64'hBFD0000000000004;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3785309\n");
-    end
-    x = 64'hBFFFFFFFFFFF0000;
-    y = 64'hBFFD7E746AFB16D4;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3785923\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h3FF0000000000001;
-    z = 64'h3FB81E1E1999C633;
-    ans = 64'h3FB81E1E1999C623;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3786537\n");
-    end
-    x = 64'hC7E573ADD2BD9CFF;
-    y = 64'hBFD0001FFFFFFFDE;
-    z = 64'h3FD47F130055411E;
-    ans = 64'h47C573D8BA19424D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3787151\n");
-    end
-    x = 64'h8721FFFFFFEFFFFF;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hBFF0000000000001;
-    ans = 64'hBFF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3787765\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h3FC200001FFFFFFF;
-    z = 64'h3FDFFFF00000FFFF;
-    ans = 64'h3FDFFFF00000FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3788379\n");
-    end
-    x = 64'h401FFFF80000001E;
-    y = 64'h4000000000000000;
-    z = 64'hB7E4881AB2642528;
-    ans = 64'h402FFFF80000001E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3788993\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h3FE328C04730D7AB;
-    z = 64'h0010000000000001;
-    ans = 64'hBCA328C04730D7AA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3789607\n");
-    end
-    x = 64'h3FC44EB15655CF8C;
-    y = 64'hBFB001000000000F;
-    z = 64'hC611C5D9D036DBD6;
-    ans = 64'hC611C5D9D036DBD6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3790221\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCD1FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3790835\n");
-    end
-    x = 64'h7FD0000000020FFF;
-    y = 64'hC087364277477C0D;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3791449\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h4010000000000000;
-    z = 64'h405FFFFC0000000E;
-    ans = 64'h405FFFFC0000000E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3792063\n");
-    end
-    x = 64'hB80FFFF80000001F;
-    y = 64'h7FD824F9FC677296;
-    z = 64'hC1ECDC90E18A4273;
-    ans = 64'hF7F824F3F328F394;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3792677\n");
-    end
-    x = 64'hBFBFFFFFFFFFFFFF;
-    y = 64'h4010000000000001;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFF8000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3793291\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h381FFBFFFFFFFF7E;
-    z = 64'h402FFBFFFFEFFFFF;
-    ans = 64'h402FFBFFFFEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3793905\n");
-    end
-    x = 64'h3E8000002FFFFFFF;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'h401FFFF6FFFFFFFE;
-    ans = 64'h401FFFF7400000BE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3794519\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h37E7518E920E9CB8;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hB4A7518E920E9CB7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3795133\n");
-    end
-    x = 64'hFFFC634E56F80E2B;
-    y = 64'hC00FFE00007FFFFE;
-    z = 64'hC5927F0A4882C3A0;
-    ans = 64'hFFFC634E56F80E2B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3795747\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h4340000000000001;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'hC000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3796361\n");
-    end
-    x = 64'h40F8845913A28A1B;
-    y = 64'h3CAFFF00000007FE;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h4020000000003106;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3796975\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'h3FAC643DA383C0B4;
-    ans = 64'hC00F8E6F0971F0FA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3797589\n");
-    end
-    x = 64'h403FFFFFFFFFFB7F;
-    y = 64'h37F8000003FFFFFF;
-    z = 64'h41D020000000007E;
-    ans = 64'h41D020000000007E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3798203\n");
-    end
-    x = 64'hBE92EA44B97B547E;
-    y = 64'h7FE0000000000000;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hFE82EA44B97B547E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3798817\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hBE5FFFFFFFFFBFF0;
-    z = 64'hBFB000000FFFFFBF;
-    ans = 64'hBFB000000FFFFFBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3799431\n");
-    end
-    x = 64'hC1E0000001FDFFFF;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h400BDB005C4DF29B;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3800045\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hC3D25C01DBF7A016;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3800659\n");
-    end
-    x = 64'hB7EBFEDEC7BFCAE2;
-    y = 64'h002C4A674B537A5C;
-    z = 64'hBB70000018000000;
-    ans = 64'hBB70000018000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3801273\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h7FF0000000000000;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3801887\n");
-    end
-    x = 64'h403FDFDFFFFFFFFE;
-    y = 64'h543C00000000007F;
-    z = 64'h4010000000000000;
-    ans = 64'h548BE3E40000007D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3802501\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'h45B518F9DBC8077E;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3803115\n");
-    end
-    x = 64'h388FFFFFFE001FFE;
-    y = 64'hB80B0B869627BF01;
-    z = 64'h40869F3B701EF024;
-    ans = 64'h40869F3B701EF024;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3803729\n");
-    end
-    x = 64'h403FFFFFFFFE1FFE;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'hBFD0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3804343\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h002B6C86ECDC9502;
-    z = 64'h221BE5101396B494;
-    ans = 64'h221BE5101396B494;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3804957\n");
-    end
-    x = 64'h3F9007FFFFBFFFFE;
-    y = 64'h8000000000000001;
-    z = 64'hC04FFFFFFFFFFBFB;
-    ans = 64'hC04FFFFFFFFFFBFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3805571\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h480FFFFFFFF7F000;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3806185\n");
-    end
-    x = 64'hC3D84640FD57069E;
-    y = 64'hC6FD409D3113A6A2;
-    z = 64'hBB5A99581212CBD0;
-    ans = 64'h4AE630AEA57AE2A1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3806799\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h8000000000000000;
-    ans = 64'h0000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3807413\n");
-    end
-    x = 64'h3FC4CD0E86115DD9;
-    y = 64'hC06FFFFFFBFFFFFE;
-    z = 64'h4000000000000001;
-    ans = 64'hC043CD0E8377BC07;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3808027\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h8010000000000001;
-    z = 64'hC0CFFEFFFFFFE000;
-    ans = 64'hC0CFFEFFFFFFE000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3808641\n");
-    end
-    x = 64'h480EFFFFFFFFFFF7;
-    y = 64'hC027FFFFFFFDFFFF;
-    z = 64'hC1C3FFE000000000;
-    ans = 64'hC8473FFFFFFE0FF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3809255\n");
-    end
-    x = 64'h800000000001FFDF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3809869\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h37FFFFFFFFE0000F;
-    z = 64'h43F8DD02D524E71E;
-    ans = 64'h43F8DD02D524E71E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3810483\n");
-    end
-    x = 64'h40307FFFFFF7FFFF;
-    y = 64'hBCA0000000000000;
-    z = 64'h3FCFFFFFFFFFBFEF;
-    ans = 64'h3FCFFFFFFFFFBFAD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3811097\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFBDF;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3811711\n");
-    end
-    x = 64'hB82000040000000F;
-    y = 64'h37FFFFFFE00007FE;
-    z = 64'h33300001FFFFFEFE;
-    ans = 64'h33300001FFFFFEEE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3812325\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3812939\n");
-    end
-    x = 64'hFFF01FFFFFFFFFDF;
-    y = 64'h3CA00000005FFFFF;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'hFFF81FFFFFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3813553\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hBFD0000000000000;
-    z = 64'hFFDE00000000003F;
-    ans = 64'hFFDE00000000003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3814167\n");
-    end
-    x = 64'hBE26336215FE569D;
-    y = 64'hC02000000FFFFFFB;
-    z = 64'hBFC0800000000FFF;
-    ans = 64'hBFC07FFFD3994BA7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3814781\n");
-    end
-    x = 64'hC1F00000C0000000;
-    y = 64'hBFD0000000000001;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h41D00000C0000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3815395\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hC1D0000020000001;
-    z = 64'hBF9FFFFFFFF7FFFC;
-    ans = 64'hBF9FFFEFFFF7DFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3816009\n");
-    end
-    x = 64'hC1C00000003FEFFF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'hBFF3FFFFFFFF8000;
-    ans = 64'h41AFFFFFFDFFDFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3816623\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h43DFC00000000010;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC3500000000001FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3817237\n");
-    end
-    x = 64'h04F0001FFFFFFFFE;
-    y = 64'h3FBFFFFFFFFFFF1E;
-    z = 64'h41C003EFFFFFFFFF;
-    ans = 64'h41C003EFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3817851\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hBFE0000000000001;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3818465\n");
-    end
-    x = 64'h48351C562148E3C3;
-    y = 64'hC3C0001040000000;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'hCC051C6B92105D91;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3819079\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h357FFFFFFFC00002;
-    ans = 64'h3CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3819693\n");
-    end
-    x = 64'hCD920007FFFFFFFE;
-    y = 64'hBFF0008000000006;
-    z = 64'hBFD0008000003FFF;
-    ans = 64'h4D92009800400005;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3820307\n");
-    end
-    x = 64'hE8E000007FFFFEFF;
-    y = 64'hBFF0000000000000;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'h68E000007FFFFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3820921\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h475FFFFFFBF7FFFE;
-    z = 64'hC3D273DDF2EFC5D4;
-    ans = 64'hC420939EED937E2D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3821535\n");
-    end
-    x = 64'hC1DBFFFFFFFFE000;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h3F71FFFFFEFFFFFF;
-    ans = 64'h41EC0000000003FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3822149\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h3FFB7AD5DBD8ECB4;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3822763\n");
-    end
-    x = 64'hC1DFFFFFFFF00400;
-    y = 64'h3600000001FDFFFE;
-    z = 64'h387002000003FFFF;
-    ans = 64'h386FE400000413FA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3823377\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hC000000000000000;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3823991\n");
-    end
-    x = 64'hC33000000000207F;
-    y = 64'hC06003FFFFFFFFE0;
-    z = 64'h3FE0000000000000;
-    ans = 64'h43A0040000002067;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3824605\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hC000000000000001;
-    z = 64'hBFB00000FFF7FFFE;
-    ans = 64'hBFB00000FFF7FFDE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3825219\n");
-    end
-    x = 64'hC03CAA2122BCDDA8;
-    y = 64'h07EFFFF01FFFFFFE;
-    z = 64'h790FFFFFFFF007FF;
-    ans = 64'h790FFFFFFFF007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3825833\n");
-    end
-    x = 64'h800DFFFFFF000000;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'h8000000000000000;
-    ans = 64'h002BFFFFFDFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3826447\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h3FB00041FFFFFFFF;
-    z = 64'hED24C95B210BCE74;
-    ans = 64'hED24C95B210BCE74;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3827061\n");
-    end
-    x = 64'hBCDFFFFBFFFFFFEF;
-    y = 64'hC010000000000001;
-    z = 64'h3FE2B79A1255D879;
-    ans = 64'h3FE2B79A1255D8B9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3827675\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hBFB611A62F90914B;
-    z = 64'hC010000000000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3828289\n");
-    end
-    x = 64'h086FFDFFFFF7FFFE;
-    y = 64'h3F3FFFC00000001F;
-    z = 64'h3D1FF7FFFF7FFFFF;
-    ans = 64'h3D1FF7FFFF7FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3828903\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3829517\n");
-    end
-    x = 64'h09B0000000FFFFEF;
-    y = 64'hE16F29F8FCB12F99;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3FD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3830131\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hC340000000000000;
-    z = 64'hC04000000FEFFFFF;
-    ans = 64'hC03E00001FDFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3830745\n");
-    end
-    x = 64'hC8001FF7FFFFFFFF;
-    y = 64'h97DA61766F44B5D2;
-    z = 64'hC02FFFFFFE010000;
-    ans = 64'hC02FFFFFFE010000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3831359\n");
-    end
-    x = 64'h40300000000E0000;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3831973\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h4340000000000200;
-    z = 64'h7FD8E66F7F1B72EF;
-    ans = 64'h7FD8E66F7F1B72EF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3832587\n");
-    end
-    x = 64'hC3D9284299249F71;
-    y = 64'hFFE0000000000000;
-    z = 64'h001269432C741CE2;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3833201\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hC34000000801FFFE;
-    z = 64'hC000000000000001;
-    ans = 64'h3E7003FFF8FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3833815\n");
-    end
-    x = 64'h3FC0000100000FFF;
-    y = 64'h402F2113B98F4D3F;
-    z = 64'h41F5067733275A4B;
-    ans = 64'h41F5067733467B61;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3834429\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h4010000000000001;
-    ans = 64'h7CAFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3835043\n");
-    end
-    x = 64'h41FEFFFFF7FFFFFE;
-    y = 64'h3FDE27B3C3560C4A;
-    z = 64'h3CAFFFFFFFFFFFFF;
-    ans = 64'h41ED36761DB16EF5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3835657\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'hBFC01FFF00000000;
-    ans = 64'h7CAFFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3836271\n");
-    end
-    x = 64'hA140000020FFFFFF;
-    y = 64'hC02200000001FFFF;
-    z = 64'hA270000007FFFFDF;
-    ans = 64'hA26FFFDC0FFFB57A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3836885\n");
-    end
-    x = 64'h3FCFFFFFFF80000F;
-    y = 64'hFFF0000000000001;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3837499\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'hC1E0010000000040;
-    z = 64'h001FFEFFFFFFFFBF;
-    ans = 64'h3EA001000000003F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3838113\n");
-    end
-    x = 64'hBE2FDFBFFFFFFFFE;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hC3E0000000000402;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3838727\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFF;
-    y = 64'h401FFFFF7FFFFDFE;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hC000000000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3839341\n");
-    end
-    x = 64'h400AF78C8712BABC;
-    y = 64'h8020003FFFFFDFFE;
-    z = 64'h3F0FFFFF02000000;
-    ans = 64'h3F0FFFFF02000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3839955\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h0000000000000001;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3840569\n");
-    end
-    x = 64'h47FCF758F173AEC0;
-    y = 64'hB81000003FBFFFFE;
-    z = 64'h001FFFFFFFFFFFFE;
-    ans = 64'hC01CF75964DD351E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3841183\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'hBFE4000000007FFF;
-    ans = 64'hBFE4000000007FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3841797\n");
-    end
-    x = 64'h407017FFFFFFFFFF;
-    y = 64'hC34C07FFFFFFFFFF;
-    z = 64'h3A6F7FFBFFFFFFFF;
-    ans = 64'hC3CC320BFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3842411\n");
-    end
-    x = 64'h47F000000027FFFF;
-    y = 64'h0010000000000000;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3843025\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hB7F003FFFFFFEFFE;
-    z = 64'hC5B7A0673EADC9A4;
-    ans = 64'hC5B7A0673EADC9A4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3843639\n");
-    end
-    x = 64'h409020000003FFFF;
-    y = 64'h0010000000000001;
-    z = 64'hC00FF00000000400;
-    ans = 64'hC00FF00000000400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3844253\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hC01623760D068163;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFF3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3844867\n");
-    end
-    x = 64'h093FFE0000000001;
-    y = 64'hBE42C37D10FC5DBF;
-    z = 64'hBF9EDB6E0C31FE0D;
-    ans = 64'hBF9EDB6E0C31FE0D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3845481\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h3CA0000000000000;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'h3FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3846095\n");
-    end
-    x = 64'hBFF0800000020000;
-    y = 64'h002FFFFFFFFFFDE0;
-    z = 64'h0010000000000000;
-    ans = 64'h802900000003FDCF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3846709\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h3CA0000000000001;
-    z = 64'h41EFF8000000003E;
-    ans = 64'h41EFF8000000003E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3847323\n");
-    end
-    x = 64'hC008000001FFFFFF;
-    y = 64'h4037FFFFDFFFFFFF;
-    z = 64'h3C5020000007FFFE;
-    ans = 64'hC051FFFFE97FFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3847937\n");
-    end
-    x = 64'h43D286A2997C9FAA;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h4340000000000000;
-    ans = 64'h4340000000000251;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3848551\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h402D452A3DF3776D;
-    z = 64'hC1EFFFFFFFEFFFBF;
-    ans = 64'hC1EFFFFFFFEFFFBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3849165\n");
-    end
-    x = 64'h4007FFFFFFFFFF7F;
-    y = 64'h3FD0000000000000;
-    z = 64'h7FD5398280BE5715;
-    ans = 64'h7FD5398280BE5715;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3849779\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h41FF6F065BD57EC9;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE00003EDE0CB7B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3850393\n");
-    end
-    x = 64'h56CFFFFC00007FFF;
-    y = 64'hC3FFFDFFFFC00000;
-    z = 64'hB890000040001FFF;
-    ans = 64'hDADFFDFC00007FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3851007\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h3FF0000000000000;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3851621\n");
-    end
-    x = 64'h4031E6B8C563AF80;
-    y = 64'hBCAFFFFFFF8000FF;
-    z = 64'h0000000000000001;
-    ans = 64'hBCF1E6B8C51C152C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3852235\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h3FE0000000000000;
-    z = 64'hBF463F4F8D229935;
-    ans = 64'hBF463F4F8D229D35;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3852849\n");
-    end
-    x = 64'hACAFFFFFFFFFFFFB;
-    y = 64'hC0100000207FFFFF;
-    z = 64'h3FEFFFFFF01FFFFE;
-    ans = 64'h3FEFFFFFF01FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3853463\n");
-    end
-    x = 64'h001FFFC000000000;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3854077\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h2929BC17AB77C1CB;
-    z = 64'h3F203FFFFFFFFFFD;
-    ans = 64'h3F203FFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3854691\n");
-    end
-    x = 64'hBFFE5222CB6C08EC;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'hC02FEFFFFFFFFFDF;
-    ans = 64'hC031DD222CB6C07E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3855305\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hB807EFFFFFFFFFFF;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3855919\n");
-    end
-    x = 64'hF05000000080007E;
-    y = 64'hC1F00007FFFFFF7F;
-    z = 64'h4014EE1CFC92B761;
-    ans = 64'h725000080080003D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3856533\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FDFFFFFFFFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3857147\n");
-    end
-    x = 64'hC02DFBFFFFFFFFFE;
-    y = 64'h47AFF00000080000;
-    z = 64'hFFFFFFFFFFFFFFFF;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3857761\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h3FCF4975D48A2613;
-    ans = 64'h3FCF4975D48A2603;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3858375\n");
-    end
-    x = 64'hC0FAFEC2EE7775CF;
-    y = 64'h447FFFFFFFFFFFFF;
-    z = 64'h3FBF000000FFFFFF;
-    ans = 64'hC58AFEC2EE7775CE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3858989\n");
-    end
-    x = 64'h45EEE82BC0898FB7;
-    y = 64'h4000000000000001;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h45FEE82BC0898FB9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3859603\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h402FFFFFFFF00200;
-    z = 64'hACDFFFDFFFFFFDFE;
-    ans = 64'hBCEFFFFFFFF001FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3860217\n");
-    end
-    x = 64'h41300001FFFFEFFF;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h41C3B0198D9CC68F;
-    ans = 64'h41C3D019919CC66F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3860831\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h41A0000200002000;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBE60000202001FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3861445\n");
-    end
-    x = 64'h401D7976478C5506;
-    y = 64'h41EFFFFFFF800200;
-    z = 64'h37FFF07FFFFFFFFF;
-    ans = 64'h421D797647167104;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3862059\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h4010000000000001;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h3FDFFFFFFFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3862673\n");
-    end
-    x = 64'h37E200FFFFFFFFFF;
-    y = 64'hBFF00000008001FF;
-    z = 64'hFFEFFFFFFFFFFFFE;
-    ans = 64'hFFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3863287\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h3FBF000007FFFFFF;
-    ans = 64'h3FBF000007FFFF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3863901\n");
-    end
-    x = 64'h706FFFFFFFEFEFFF;
-    y = 64'hBB2007994AC8C940;
-    z = 64'h43EFFFFFF0000001;
-    ans = 64'hEBA007994AC0BD6F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3864515\n");
-    end
-    x = 64'hBFDFFEFFFDFFFFFE;
-    y = 64'h4340000000000000;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'hC32FFEFFFDFFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3865129\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h7D2A71E23A26FE39;
-    z = 64'hC3CEDFFFFFFFFFFF;
-    ans = 64'hF9EA71E23A26FE37;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3865743\n");
-    end
-    x = 64'hB7E7FFEFFFFFFFFF;
-    y = 64'h4340000000000001;
-    z = 64'h3FF0262BF9110EA2;
-    ans = 64'h3FF0262BF9110EA2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3866357\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hFFF28BE96C71A6EB;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'hFFFA8BE96C71A6EB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3866971\n");
-    end
-    x = 64'hC34BFFBFFFFFFFFE;
-    y = 64'h4020003FFFFFFFFC;
-    z = 64'hC000000000000203;
-    ans = 64'hC37C002FFEFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3867585\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h7FE0000000000000;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'hFC9FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3868199\n");
-    end
-    x = 64'h4070000000000047;
-    y = 64'h3FD001FFFFFFFFF6;
-    z = 64'hFFE0000000000000;
-    ans = 64'hFFE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3868813\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h7FE0000000000001;
-    z = 64'h41C000F800000000;
-    ans = 64'hFCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3869427\n");
-    end
-    x = 64'h480000000800007F;
-    y = 64'hC1DFFFFFFFFFFFFE;
-    z = 64'h480D431676A71F4C;
-    ans = 64'hC9F0000007C57A51;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3870041\n");
-    end
-    x = 64'hC1E0C51250FC8976;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'h3FF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3870655\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h41EE000000000007;
-    z = 64'hC1E010000007FFFE;
-    ans = 64'hC1E0100000080000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3871269\n");
-    end
-    x = 64'h41AFF68C1CC9C0A1;
-    y = 64'h7FF0000000000000;
-    z = 64'h434FFFFFFFBFFEFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3871883\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h3FFFFFFFBFFFBFFF;
-    z = 64'h8010000000000000;
-    ans = 64'hBCBFFFFFBFFFBFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3872497\n");
-    end
-    x = 64'h400DC9E58AFDDB5A;
-    y = 64'h47EFFFFDFFFFFFFA;
-    z = 64'h001FFFFFFFFFC200;
-    ans = 64'h480DC9E3AE5F82A5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3873111\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h3CA0000000000000;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3873725\n");
-    end
-    x = 64'hBFF0007FFFBFFFFF;
-    y = 64'hBFDCC57F4F7CBEBC;
-    z = 64'hC340000000000001;
-    ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3874339\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h8000000000000000;
-    z = 64'h5E2FFFFFFFFFFFE8;
-    ans = 64'h5E2FFFFFFFFFFFE8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3874953\n");
-    end
-    x = 64'hBE91FFFFFFFFFFFA;
-    y = 64'h40A000000FFFBFFF;
-    z = 64'hC0207FEFFFFFFFFE;
-    ans = 64'hC0208038000047FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3875567\n");
-    end
-    x = 64'h3FFFC001FFFFFFFE;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'h3FE0000000000001;
-    ans = 64'h3FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3876181\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hC1A000000000006E;
-    z = 64'h37E0000100010000;
-    ans = 64'h3E6000000000006D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3876795\n");
-    end
-    x = 64'h3FEFF7EFFFFFFFFF;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'hFFD3413A55613D63;
-    ans = 64'hFFD3413A55613D63;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3877409\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h001FFFFFFFFC0000;
-    z = 64'h8000000000000001;
-    ans = 64'h8000000000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3878023\n");
-    end
-    x = 64'hCE58341C1FDF7D8E;
-    y = 64'hC02FFFFFFFFE0007;
-    z = 64'hC340010000100000;
-    ans = 64'h4E98341C1FDDFA52;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3878637\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'h0010000000000001;
-    ans = 64'h0010000000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3879251\n");
-    end
-    x = 64'hCDFFFFFFFFFF803F;
-    y = 64'h52CFBFFFE0000000;
-    z = 64'hC01FFFFFFFFFFFFF;
-    ans = 64'hE0DFBFFFDFFF813F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3879865\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'hBC7000007FFFFFBF;
-    ans = 64'hBC7000007FFFFFBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3880479\n");
-    end
-    x = 64'h7FFFFFDFFFFFF7FF;
-    y = 64'hBFFEAF36380E1453;
-    z = 64'h43401FFFFFFEFFFF;
-    ans = 64'h7FFFFFDFFFFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3881093\n");
-    end
-    x = 64'hC7E000000000041F;
-    y = 64'hBCA0000000000001;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h4490000000000420;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3881707\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h4340011FFFFFFFFF;
-    z = 64'hC48F000001FFFFFF;
-    ans = 64'hC48F000001FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3882321\n");
-    end
-    x = 64'hFFFBFFFFFFFFFEFF;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h3F400000011FFFFE;
-    ans = 64'hFFFBFFFFFFFFFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3882935\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h40207F0000000000;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3883549\n");
-    end
-    x = 64'h971F800000001FFE;
-    y = 64'hD6EC0000FFFFFFFF;
-    z = 64'h38DFFFFFFC000001;
-    ans = 64'h38DFFFFFFC000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3884163\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hBFD0000000000001;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h3C90000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3884777\n");
-    end
-    x = 64'h7943721AAF4997DF;
-    y = 64'h4F40100000001FFE;
-    z = 64'hC00FFFFFFFFFFFFE;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3885391\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'hC03DFFFFEFFFFFFE;
-    ans = 64'hC03DFFFFEFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3886005\n");
-    end
-    x = 64'hC02FFFFFFFFD0000;
-    y = 64'h409FFFFFE0003FFF;
-    z = 64'h41F000800000000E;
-    ans = 64'h41F000780000080F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3886619\n");
-    end
-    x = 64'hBCA8CBF09B3D0FC8;
-    y = 64'hBFE0000000000000;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h3CB632FC26CF43F1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3887233\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hBFE0000004000040;
-    z = 64'h3FCA4E5DFC5F64A6;
-    ans = 64'h3FCA4E5DFC5F64AA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3887847\n");
-    end
-    x = 64'hC7FFF000000FFFFF;
-    y = 64'hBFE0000000000001;
-    z = 64'h3B988E26CAA0A643;
-    ans = 64'h47EFF00000100001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3888461\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hBFFA89B78C407B0B;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3889075\n");
-    end
-    x = 64'h7FEC5FED92358A74;
-    y = 64'h400000001BFFFFFF;
-    z = 64'hFFEFC0003FFFFFFE;
-    ans = 64'h7FE8FFDB47BAD466;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3889689\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3890303\n");
-    end
-    x = 64'h3E5003FFFFFFFFFE;
-    y = 64'h42A0000100000008;
-    z = 64'hC000000000000000;
-    ans = 64'h410003F100400006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3890917\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hBFF0000000000001;
-    z = 64'h3F90FFFE00000000;
-    ans = 64'h3F90FFFE00000040;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3891531\n");
-    end
-    x = 64'h43A379C662D1E18D;
-    y = 64'hBFEFFFFFFFFFFE0E;
-    z = 64'hCE7FFD7FFFFFFFFF;
-    ans = 64'hCE7FFD7FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3892145\n");
-    end
-    x = 64'h3F700000000BFFFE;
-    y = 64'hBFFFFFFFFFFFFFFE;
-    z = 64'h3CA0000000000000;
-    ans = 64'hBF800000000BFFBD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3892759\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hB81AEAA04CF56914;
-    z = 64'h43EFE00000010000;
-    ans = 64'h43EFE00000010000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3893373\n");
-    end
-    x = 64'hBFFEFFFFFEFFFFFE;
-    y = 64'hC000000000000000;
-    z = 64'h9CF00401FFFFFFFE;
-    ans = 64'h400EFFFFFEFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3893987\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hBF1FC0000001FFFF;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3894601\n");
-    end
-    x = 64'h48000200000007FF;
-    y = 64'hC7E804BB70801D06;
-    z = 64'h402BCF7F1D62AAF3;
-    ans = 64'hCFF807BC07EE390A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3895215\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3895829\n");
-    end
-    x = 64'hC01816EFAAB2D8D7;
-    y = 64'hC3DFFFBFFFFF7FFF;
-    z = 64'hBFF0000000000001;
-    ans = 64'h440816BF7CD32315;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3896443\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hC010000000000000;
-    z = 64'h37F8101B8771DC21;
-    ans = 64'h3CCFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3897057\n");
-    end
-    x = 64'hC347ED246FACE56C;
-    y = 64'h41B00000FFFFFBFF;
-    z = 64'hC3C01FFFFFFFE000;
-    ans = 64'hC507ED26F07F266A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3897671\n");
-    end
-    x = 64'h43D34792C6A02B3D;
-    y = 64'hC01FFFFFFFFFFFFF;
-    z = 64'h0010000000000001;
-    ans = 64'hC4034792C6A02B3C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3898285\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h801974EC8F423A9C;
-    z = 64'h7FEFFFFFFFFFF5FE;
-    ans = 64'h7FEFFFFFFFFFF5FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3898899\n");
-    end
-    x = 64'hBFD000001FFFFF7F;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'hC6C6597A88729CE8;
-    ans = 64'hC6C6597A88729CE8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3899513\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hC1DFFFFFFFFDDFFF;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3900127\n");
-    end
-    x = 64'h3E90001FFFFBFFFF;
-    y = 64'h000007FFFFFFFEFF;
-    z = 64'h43FFEFFFFFFFFFEF;
-    ans = 64'h43FFEFFFFFFFFFEF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3900741\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hC340000000000001;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3901355\n");
-    end
-    x = 64'h354C0618970ED58A;
-    y = 64'hC29FFFFDFFFFFFFB;
-    z = 64'hBFEFFFFFFFFFFFFF;
-    ans = 64'hBFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3901969\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'hBFEFC000FFFFFFFF;
-    ans = 64'h40080FFFBFFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3902583\n");
-    end
-    x = 64'hC008000007FFFFFF;
-    y = 64'hC3E0007FDFFFFFFE;
-    z = 64'hC020001FFFF7FFFE;
-    ans = 64'h43F800BFD8003FEC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3903197\n");
-    end
-    x = 64'h7FE037FFFFFFFFFF;
-    y = 64'hFFE0000000000001;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3903811\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h43EFFFFFFFFFC1FF;
-    z = 64'hC08FFFFFFFFFE080;
-    ans = 64'hC0B3FFFFFFFFDD0F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3904425\n");
-    end
-    x = 64'hC1C000000001007E;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h37F0000000000808;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3905039\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'h47EE1258EDCF0B99;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'hC4AE1258EDCF0B97;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3905653\n");
-    end
-    x = 64'hC01FF00100000000;
-    y = 64'h37E2C1CE2980BFCB;
-    z = 64'hBFF000C000000000;
-    ans = 64'hBFF000C000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3906267\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hFFF0000000000000;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3906881\n");
-    end
-    x = 64'h415FED03662395C2;
-    y = 64'h3CF003FFFFC00000;
-    z = 64'hBFDFFFFFFFFFFFFE;
-    ans = 64'hBFDFFFFFE00B0158;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3907495\n");
-    end
-    x = 64'hBCAFFFFFFFFFFFFE;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'hB81FFFFFFFFFF7C0;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3908109\n");
-    end
-    x = 64'h7FEFFFDFFFFFF000;
-    y = 64'h3E92B79EE102830F;
-    z = 64'h404FF80002000000;
-    ans = 64'h7E92B78C296398B1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3908723\n");
-    end
-    x = 64'h3FCFFFFFFFFFEEFE;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3909337\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hC463FFFFFFFF7FFF;
-    z = 64'hB80FFFFFFF0001FE;
-    ans = 64'h4443FFFFFFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3909951\n");
-    end
-    x = 64'h41DFFF7FFFFFFFFD;
-    y = 64'h0000000000000001;
-    z = 64'h40074A735CCC3D1A;
-    ans = 64'h40074A735CCC3D1A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3910565\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hBE700000003DFFFE;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h4010000000FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3911179\n");
-    end
-    x = 64'hC0EFFFFFFFFFFBFE;
-    y = 64'hBFB5337C5E8A0ADB;
-    z = 64'h403FFFFFFFF80100;
-    ans = 64'h40B5537C5E8A0034;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3911793\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3912407\n");
-    end
-    x = 64'h40FBFFEFFFFFFFFF;
-    y = 64'h407BCCA8CD7A0FA4;
-    z = 64'hBFD0000000000000;
-    ans = 64'h41885305CB7666F2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3913021\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h0010000000000001;
-    z = 64'h47FBFF8000000000;
-    ans = 64'h47FBFF8000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3913635\n");
-    end
-    x = 64'h80070F86D26AF87F;
-    y = 64'h402D24956BD2F299;
-    z = 64'h3FEFFFFFFEFFFFDF;
-    ans = 64'h3FEFFFFFFEFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3914249\n");
-    end
-    x = 64'h802FB75B257B0ED8;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3914863\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h3E10000000000000;
-    z = 64'hB7E8C5327331971D;
-    ans = 64'hBDF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3915477\n");
-    end
-    x = 64'h3FF0020000010000;
-    y = 64'h3CA0000000000000;
-    z = 64'hBFDBFFFFFFFFFFC0;
-    ans = 64'hBFDBFFFFFFFFFFBE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3916091\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h3ABFFFFFF7FFBFFF;
-    z = 64'h4000000000000000;
-    ans = 64'h4000000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3916705\n");
-    end
-    x = 64'h3FCB02720DAF3235;
-    y = 64'h43E4A66C2CF152B0;
-    z = 64'h41DFC544AD43CD91;
-    ans = 64'h43C16DFF46A401F7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3917319\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'hC010000000000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3917933\n");
-    end
-    x = 64'hB7E00000003BFFFF;
-    y = 64'h3FDFFFFFFFF7DFFF;
-    z = 64'hBCA0000000000001;
-    ans = 64'hBCA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3918547\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h3FD0000000000000;
-    z = 64'h48000000000FFE00;
-    ans = 64'h48000000000FFE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3919161\n");
-    end
-    x = 64'hC03B47150C9A9B6D;
-    y = 64'hB2100800000001FF;
-    z = 64'h41200001FFFFFBFE;
-    ans = 64'h41200001FFFFFBFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3919775\n");
-    end
-    x = 64'hC800003FFFEFFFFF;
-    y = 64'h3FD0000000000001;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3920389\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h43CFFFFFFFFEDFFE;
-    z = 64'h7FD69279CD05B983;
-    ans = 64'h7FD69279CD05B983;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3921003\n");
-    end
-    x = 64'hBFDE7D87C0913C02;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'h3FDFFF7FFFFFBFFE;
-    ans = 64'h3FD0C0BC1FB721FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3921617\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hBFCFFF8000008000;
-    z = 64'h3FF0000000000001;
-    ans = 64'h3FF0FFFC00000401;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3922231\n");
-    end
-    x = 64'hE561400000000000;
-    y = 64'h3370010000000080;
-    z = 64'h3FEFFC0000000FFF;
-    ans = 64'hD8E141140000008A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3922845\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h3FE0000000000001;
-    z = 64'hC000000000000001;
-    ans = 64'hC001000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3923459\n");
-    end
-    x = 64'hB61FDFFFFFFFFF80;
-    y = 64'hC07FF7FFF7FFFFFF;
-    z = 64'h801FFFFFFFFFFFFF;
-    ans = 64'h36AFD807F807FF7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3924073\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h6F9000201FFFFFFF;
-    ans = 64'h6F9000201FFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3924687\n");
-    end
-    x = 64'hF8A00000400007FF;
-    y = 64'hC3CFFFFFFFFFE000;
-    z = 64'hBCD00FFFFFFFFFF6;
-    ans = 64'h7C8000003FFFF7FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3925301\n");
-    end
-    x = 64'hC020000007FFFFBF;
-    y = 64'h3FF0000000000000;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC350000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3925915\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hC9F4F59F1F927A15;
-    z = 64'h45E2000000000007;
-    ans = 64'h49D4F59F1F927A15;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3926529\n");
-    end
-    x = 64'h7FFE000000000003;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'h8027230E8C392E66;
-    ans = 64'h7FFE000000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3927143\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h402881AE9E66C7A0;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'hC00081AE9E66C7A0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3927757\n");
-    end
-    x = 64'h3FF07FF000000000;
-    y = 64'hB7E591AE07EF0EC1;
-    z = 64'hBFA20001FFFFFFFE;
-    ans = 64'hBFA20001FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3928371\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h4000000000000000;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hC004000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3928985\n");
-    end
-    x = 64'h41F0000000FFF7FE;
-    y = 64'hB43FFFFFE0000000;
-    z = 64'h800FFFFFFFFFFFFE;
-    ans = 64'hB63FFFFFE1FFEFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3929599\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h401FFFF7FFFFBFFF;
-    ans = 64'h401BFFF7FFFFBFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3930213\n");
-    end
-    x = 64'h41E0020007FFFFFE;
-    y = 64'hBFCFFFFFFFF80000;
-    z = 64'h41CC685C7196EB8B;
-    ans = 64'h41B8CCB8D335D81A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3930827\n");
-    end
-    x = 64'hD59FFFFFFFFFFF02;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hD5BFFFFFFFFFFF00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3931441\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h3ECF0000001FFFFE;
-    z = 64'hC07FFFFFF7FFFF00;
-    ans = 64'hC07FFFFFF8F7FF00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3932055\n");
-    end
-    x = 64'hD3207FFFF8000000;
-    y = 64'h4010000000000001;
-    z = 64'h802FFF7FF7FFFFFF;
-    ans = 64'hD3407FFFF8000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3932669\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hC1E000000000EFFF;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h41C000000040EFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3933283\n");
-    end
-    x = 64'h47E0001FFEFFFFFF;
-    y = 64'h3E00080001FFFFFF;
-    z = 64'h3F80400001FFFFFE;
-    ans = 64'h45F0082010FF83FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3933897\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hC007FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3934511\n");
-    end
-    x = 64'h43CFFFFFFFFFBFFC;
-    y = 64'h48000103FFFFFFFF;
-    z = 64'h8000000000000000;
-    ans = 64'h4BE00103FFFFDFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3935125\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h4340000000000001;
-    z = 64'hB2A1894A6694767C;
-    ans = 64'hC320000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3935739\n");
-    end
-    x = 64'hBFF00000001FFFDF;
-    y = 64'h43E49E7F564BB504;
-    z = 64'h3FDFF80000800000;
-    ans = 64'hC3E49E7F5674F1D8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3936353\n");
-    end
-    x = 64'h326FFF0000001FFF;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hC010000000000000;
-    ans = 64'hC010000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3936967\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hBFB0000080800000;
-    z = 64'h5CBFFFFFFFC00010;
-    ans = 64'h5CBFFFFFFFC00010;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3937581\n");
-    end
-    x = 64'hC04C000000000002;
-    y = 64'h7FE0000000000000;
-    z = 64'hC7F0003FFF800000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3938195\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hB7F00000000FEFFE;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3938809\n");
-    end
-    x = 64'hC07FFFFF000000FF;
-    y = 64'h401FFFFFFC000800;
-    z = 64'hBFFE3FFFFFFFFFFF;
-    ans = 64'hC0B001E37E00048F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3939423\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hBFE0000000000000;
-    ans = 64'hFFCFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3940037\n");
-    end
-    x = 64'h43D45470894BB8A8;
-    y = 64'hC03FBFFFBFFFFFFF;
-    z = 64'h7FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3940651\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h7FF0000000000000;
-    z = 64'hC0100000000077FF;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3941265\n");
-    end
-    x = 64'hC1CF9BD668BBFDD4;
-    y = 64'h47FFFFFFFC00000F;
-    z = 64'h3FF0000203FFFFFE;
-    ans = 64'hC9DF9BD664C88316;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3941879\n");
-    end
-    x = 64'h94B6F716776052E0;
-    y = 64'h7FF0000000000001;
-    z = 64'hC000000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3942493\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h7FF0001000001FFE;
-    z = 64'h3FCD83E74EDEE6A0;
-    ans = 64'h7FF8001000001FFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3943107\n");
-    end
-    x = 64'h3F8FFFFFDFFFBFFF;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'h3ECFE0003FFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3943721\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h43C6363479265EB6;
-    z = 64'h3CA0000000000001;
-    ans = 64'hC3A6363479265EB6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3944335\n");
-    end
-    x = 64'hBE7FFFFFE0007FFF;
-    y = 64'h3F8FFFFFFFFFF820;
-    z = 64'h48000000003FFE00;
-    ans = 64'h48000000003FFE00;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3944949\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h8000000000000001;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3945563\n");
-    end
-    x = 64'h7FFE5CD16B7C0732;
-    y = 64'h3CADFFFFFFDFFFFF;
-    z = 64'h7FEFFFFFFFFFFFFF;
-    ans = 64'h7FFE5CD16B7C0732;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3946177\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h800FFFFFFFFFFFFE;
-    z = 64'h409BFFFFEFFFFFFF;
-    ans = 64'h409BFFFFEFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3946791\n");
-    end
-    x = 64'hBF9FFFFFEFFFFFC0;
-    y = 64'h381EF14093430C09;
-    z = 64'hD060000FFFFFC000;
-    ans = 64'hD060000FFFFFC000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3947405\n");
-    end
-    x = 64'h00200001FFFFF000;
-    y = 64'h8010000000000000;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3948019\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h8023FFFFFFFFFFF6;
-    z = 64'hC3EFFFFFFFFF007F;
-    ans = 64'hC3EFFFFFFFFF007F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3948633\n");
-    end
-    x = 64'hA60FDFFFBFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hC7FBFFC000000000;
-    ans = 64'hC7FBFFC000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3949247\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h498168AE9F10A60B;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'hC96168AE9F10A60B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3949861\n");
-    end
-    x = 64'h400FFFEFFBFFFFFF;
-    y = 64'h3FC000FF7FFFFFFF;
-    z = 64'h4F83DECC52B7FEC8;
-    ans = 64'h4F83DECC52B7FEC8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3950475\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hBCA0000000000000;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'hBCABFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3951089\n");
-    end
-    x = 64'h000FFF7FFBFFFFFE;
-    y = 64'h37EFFE003FFFFFFE;
-    z = 64'h434FFFFFFFFFFFFE;
-    ans = 64'h434FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3951703\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hBCAFFFFFFFFFFFFF;
-    z = 64'h7FF00000000007FF;
-    ans = 64'h7FF80000000007FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3952317\n");
-    end
-    x = 64'h3FB00000000BFFFF;
-    y = 64'hC1F4D10E1B0B1A8D;
-    z = 64'h323FFFFFC000003E;
-    ans = 64'hC1B4D10E1B1AB756;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3952931\n");
-    end
-    x = 64'hFE40041FFFFFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'h7B00041FFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3953545\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hC1CFFFFF00000080;
-    z = 64'h592B8A3E51BB758C;
-    ans = 64'h592B8A3E51BB758C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3954159\n");
-    end
-    x = 64'hB7E28718D241C8CE;
-    y = 64'hBFD0000000000001;
-    z = 64'hC5BFFFE00000000F;
-    ans = 64'hC5BFFFE00000000F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3954773\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hC1C0ECDAF428D873;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h41A0ECDAF428D873;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3955387\n");
-    end
-    x = 64'hC1D01FFFFEFFFFFF;
-    y = 64'hBD900000000017FE;
-    z = 64'h4020000100000006;
-    ans = 64'h40200204FFFFE009;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3956001\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h3FBFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3956615\n");
-    end
-    x = 64'hBFECB2362DE0F377;
-    y = 64'hC7FFFFFFF00003FE;
-    z = 64'h4340000000000000;
-    ans = 64'h47FCB2361F87DBF5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3957229\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hBFE0000000000001;
-    z = 64'hC0EB2BD633D0A462;
-    ans = 64'hC0EB2BD233D0A462;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3957843\n");
-    end
-    x = 64'hC4909D047E2E3993;
-    y = 64'h3FC0021FFFFFFFFE;
-    z = 64'hC1D029717C79EE32;
-    ans = 64'hC4609F3958C703C9;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3958457\n");
-    end
-    x = 64'h3FD3FFFFFFFFFDFF;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'hBFE0000000000000;
-    ans = 64'hBFE9FFFFFFFFFEFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3959071\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h8011FFFFFFFBFFFF;
-    z = 64'hC0B0000000402000;
-    ans = 64'hC0B0000000402000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3959685\n");
-    end
-    x = 64'hBFD0000007FFFBFF;
-    y = 64'hBFF0000000000000;
-    z = 64'h3F30000040020000;
-    ans = 64'h3FD00400080FFC7F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3960299\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hC1F01FFFFFFFFFDF;
-    z = 64'h0000000000000000;
-    ans = 64'h41D01FFFFFFFFFDF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3960913\n");
-    end
-    x = 64'h4062E6BD1223E0B2;
-    y = 64'h37F0021FFFFFFFFF;
-    z = 64'h002C0007FFFFFFFF;
-    ans = 64'h3862E93FB7404975;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3961527\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h8010000000000000;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3962141\n");
-    end
-    x = 64'h80072CA6F5A92C4D;
-    y = 64'hB7EE00001FFFFFFF;
-    z = 64'h4010000000000001;
-    ans = 64'h4010000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3962755\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hC000000000000000;
-    z = 64'h3FF0007FFFFFFFFB;
-    ans = 64'h3FF8007FFFFFFFFB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3963369\n");
-    end
-    x = 64'hC0139A6B29FE9D78;
-    y = 64'h4DEFFAFFFFFFFFFF;
-    z = 64'h421DFE0000000000;
-    ans = 64'hCE13975B09400DAF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3963983\n");
-    end
-    x = 64'hBB4FFFFFFE000007;
-    y = 64'hC000000000000001;
-    z = 64'hBFD0000000000001;
-    ans = 64'hBFD0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3964597\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h3E1000020003FFFF;
-    z = 64'h407EFFFFFFBFFFFF;
-    ans = 64'h407EFFFFFFBFEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3965211\n");
-    end
-    x = 64'hC8000007FFFFFEFF;
-    y = 64'hC00FFFFFFFFFFFFE;
-    z = 64'hC03FFFFFFFDFFFE0;
-    ans = 64'h48200007FFFFFEFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3965825\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h37E0000010000000;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3966439\n");
-    end
-    x = 64'hBFEFFFFFFDFFFFDE;
-    y = 64'hFFEBFFFFFFFE0000;
-    z = 64'h3FB0800000000020;
-    ans = 64'h7FEBFFFFFE3DFFE2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3967053\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hC010000000000001;
-    z = 64'h8000000000000001;
-    ans = 64'h3FF0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3967667\n");
-    end
-    x = 64'h29D0003F7FFFFFFF;
-    y = 64'hC3D05FFFFFFFFFFF;
-    z = 64'h400FFFFFFFFFFFFF;
-    ans = 64'h400FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3968281\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hC01FFFFFFFFFFFFE;
-    z = 64'h41F9A49D2E0B0DFF;
-    ans = 64'h41F9A49D2E2B0DFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3968895\n");
-    end
-    x = 64'hC280000FFEFFFFFF;
-    y = 64'h3FD0000FFFEFFFFE;
-    z = 64'h43DC00000000FFFF;
-    ans = 64'h43DBFFFFE000C001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3969509\n");
-    end
-    x = 64'hC80679B587B79104;
-    y = 64'hC340000000000000;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'h4B5679B587B79104;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3970123\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h5CC53197EE2C973A;
-    z = 64'h1AD0FF0000000000;
-    ans = 64'hDCA53197EE2C973A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3970737\n");
-    end
-    x = 64'hC14F1FFFFFFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFF;
-    z = 64'hC3EF6FA933DE8BF0;
-    ans = 64'h44AF1E09056CC215;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3971351\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hBFB00000FDFFFFFF;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3971965\n");
-    end
-    x = 64'hC80FFFFF7F7FFFFF;
-    y = 64'h279FFFFFBFFFFF80;
-    z = 64'hC06100000000003E;
-    ans = 64'hC06100000000003E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3972579\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hFFE0000000000000;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3973193\n");
-    end
-    x = 64'hBF60003FFFFFFFBF;
-    y = 64'h4320003EF7E4B7E8;
-    z = 64'h3FFFFFFFFFFFFFFE;
-    ans = 64'hC290007EF8E08F3A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3973807\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hFFEFFFFFFFFFFFFF;
-    z = 64'h47F384676A9D2C88;
-    ans = 64'h7FCFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3974421\n");
-    end
-    x = 64'h3D0FFFFFFFFC00FF;
-    y = 64'hB61FFFFFF0000007;
-    z = 64'hC078FFFFFFFFFFFF;
-    ans = 64'hC078FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3975035\n");
-    end
-    x = 64'h3C0FFFFFFFFBBFFF;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'hFC0FFFFFFFFBBFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3975649\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hC0FB7ABF90C30569;
-    z = 64'hAA8003FFFFFFFFFA;
-    ans = 64'h40DB7ABF90C30569;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3976263\n");
-    end
-    x = 64'h4974638EBBF64A3F;
-    y = 64'hFFF0000000000001;
-    z = 64'h00200080000FFFFF;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3976877\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'h07E47CFB53657A81;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3977491\n");
-    end
-    x = 64'hC1BFFFEFFFEFFFFE;
-    y = 64'hBFEFFFFFFDFFF000;
-    z = 64'hBFBBFFFFFFFFF800;
-    ans = 64'h41BFFFEFFDD3F0FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3978105\n");
-    end
-    x = 64'hBFD0000000000000;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3978719\n");
-    end
-    x = 64'hC05FFFFFFFFF803F;
-    y = 64'hEA7FFF007FFFFFFF;
-    z = 64'h3FF0000000000000;
-    ans = 64'h6AEFFF007FFF8042;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3979333\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h0000000000000001;
-    z = 64'h41B8C52945BBFAB5;
-    ans = 64'h41B8C52945BBFAB5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3979947\n");
-    end
-    x = 64'h090000000000000F;
-    y = 64'h8013DEB27E87ED71;
-    z = 64'h354FFEFFFFFFF000;
-    ans = 64'h354FFEFFFFFFF000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3980561\n");
-    end
-    x = 64'h400FFFE000000010;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h8010000000000000;
-    ans = 64'h0027FFE00000000E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3981175\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h39BFFFFE00000007;
-    z = 64'h40345ABEA176FD65;
-    ans = 64'h40345ABEA176FD65;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3981789\n");
-    end
-    x = 64'hC02313215AE5236A;
-    y = 64'h0010000000000000;
-    z = 64'h380FFFFFFFC00000;
-    ans = 64'h380FFFFFFFC00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3982403\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h3FFEFFFFFFFFC000;
-    z = 64'hC340000000000000;
-    ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3983017\n");
-    end
-    x = 64'hC3E00000003FBFFF;
-    y = 64'h3F900000002FFFFF;
-    z = 64'hBABB1E081B1414D0;
-    ans = 64'hC3800000006FBFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3983631\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3984245\n");
-    end
-    x = 64'h7B4FFE0001FFFFFF;
-    y = 64'hB94FFFFFFFE0000F;
-    z = 64'h3FE0000000000001;
-    ans = 64'hF4AFFE0001E0020E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3984859\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h001FFFFFFFFFFFFE;
-    z = 64'hC80FFFDE00000000;
-    ans = 64'hC80FFFDE00000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3985473\n");
-    end
-    x = 64'h43EFE0000007FFFF;
-    y = 64'h801B33C01CF5799F;
-    z = 64'h4036381A5D52DCFF;
-    ans = 64'h4036381A5D52DCFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3986087\n");
-    end
-    x = 64'h3E3FFFEF00000000;
-    y = 64'h3CA0000000000001;
-    z = 64'h8000000000000001;
-    ans = 64'h3AEFFFEF00000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3986701\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hC2963A2744C815E7;
-    z = 64'h5770FFF800000000;
-    ans = 64'h5770FFF800000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3987315\n");
-    end
-    x = 64'h002FFFFFEFFFFFF7;
-    y = 64'h3CAFFFFFFFFFFFFE;
-    z = 64'h43C15567C6CBF43C;
-    ans = 64'h43C15567C6CBF43C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3987929\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h43F0040000000001;
-    z = 64'hC010000000000001;
-    ans = 64'hC3D0040000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3988543\n");
-    end
-    x = 64'h41E67E7D7E29C6E8;
-    y = 64'h80113BE435615CD1;
-    z = 64'hC7EFFBFFFFFFBFFE;
-    ans = 64'hC7EFFBFFFFFFBFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3989157\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h3FD0000000000001;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3989771\n");
-    end
-    x = 64'hC1C0008000001FFF;
-    y = 64'hC1E8B82EC582271A;
-    z = 64'h3FDFFFFFFFFFFFFF;
-    ans = 64'h43B8B8F486F8849A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3990385\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h3FDFFFFFFFFFFFFF;
-    z = 64'hC0001FFFFFEFFFFF;
-    ans = 64'hC0011FFFFFEFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3990999\n");
-    end
-    x = 64'h3ED37FFFFFFFFFFE;
-    y = 64'hFFF5DF829A8187D2;
-    z = 64'h3FC00000001FFFFF;
-    ans = 64'hFFFDDF829A8187D2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3991613\n");
-    end
-    x = 64'hBFA000007FFF7FFF;
-    y = 64'h3FE0000000000000;
-    z = 64'h7FFFFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3992227\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hC3E30BB4858318FD;
-    z = 64'h43D00000000010FE;
-    ans = 64'h43D985DA42C19D7D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3992841\n");
-    end
-    x = 64'hCDAFFE00000001FE;
-    y = 64'h3FEFFFFFFFFFFFFF;
-    z = 64'h3F1FFFFFFFC01FFF;
-    ans = 64'hCDAFFE00000001FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3993455\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h43FFFFFDFF000000;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'hC3DFFFFDFF000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3994069\n");
-    end
-    x = 64'hB800000007FFFFFF;
-    y = 64'h7FDF5D2DD7E7752E;
-    z = 64'h40AF553D70AC8668;
-    ans = 64'hF7EF5D2DE7960C18;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3994683\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h3FF0000000000000;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h401EFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3995297\n");
-    end
-    x = 64'hC80000000FDFFFFF;
-    y = 64'hC3DFFFFFFFFFFC0F;
-    z = 64'h3CAFFFFFFFFFFFFE;
-    ans = 64'h4BF000000FDFFE06;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3995911\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h3FF0000000000001;
-    z = 64'hBE8200001FFFFFFF;
-    ans = 64'hBFD0000090000102;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3996525\n");
-    end
-    x = 64'h37EB27DD446055AC;
-    y = 64'h3CA0200000008000;
-    z = 64'h00120000001FFFFE;
-    ans = 64'h349B5E2CFEE9EF96;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3997139\n");
-    end
-    x = 64'h41ED268E2DEAC13F;
-    y = 64'h3FFFFFFFFFFFFFFE;
-    z = 64'h7FEFFFFFFFFFFFFE;
-    ans = 64'h7FEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3997753\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hBFE139D0B510463B;
-    z = 64'h417F800000000008;
-    ans = 64'h417F800002273A1F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3998367\n");
-    end
-    x = 64'h47FFFFFFEFF7FFFE;
-    y = 64'h4000000000000000;
-    z = 64'h877000007FFFFFFF;
-    ans = 64'h480FFFFFEFF7FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3998981\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hC03007FFFDFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'h40000FFFFC000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"3999595\n");
-    end
-    x = 64'h40000000000000FF;
-    y = 64'h403FFFFFFFFFF00F;
-    z = 64'h3FDFFFFF7FFFFF7F;
-    ans = 64'h40501FFFFF7FF906;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4000209\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h4007FFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4000823\n");
-    end
-    x = 64'hC030400010000000;
-    y = 64'h43E80000000003FF;
-    z = 64'h3CA0000000000000;
-    ans = 64'hC42860001800040F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4001437\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h4010000000000000;
-    z = 64'h401FFFFFDFFFDFFF;
-    ans = 64'h401BFFFFDFFFDFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4002051\n");
-    end
-    x = 64'hC80FFFFF40000000;
-    y = 64'hC2FFFDDFFFFFFFFE;
-    z = 64'hBFBFFE0FFFFFFFFF;
-    ans = 64'h4B1FFDDF400CBFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4002665\n");
-    end
-    x = 64'h41EFFFFFFFDFFFDF;
-    y = 64'h401FFFFFFFFFFFFF;
-    z = 64'h7FE0000000000000;
-    ans = 64'h7FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4003279\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h403FFFFFFFC00FFF;
-    z = 64'h3FBBFFFFFBFFFFFE;
-    ans = 64'hC01F8FFFFFD01001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4003893\n");
-    end
-    x = 64'h7FE0000000FFFFFE;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hBFC00007FFFFFFFB;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4004507\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hC1E168099A1FC31E;
-    z = 64'hBFF0000000000000;
-    ans = 64'h41C16809999FC31F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4005121\n");
-    end
-    x = 64'hC0CBD59D6AA012B6;
-    y = 64'h41200000001FFEFF;
-    z = 64'h380FFFF0000FFFFE;
-    ans = 64'hC1FBD59D6AD7BC32;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4005735\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'h4000000000000000;
-    ans = 64'hC32FFFFFFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4006349\n");
-    end
-    x = 64'hC0100020FFFFFFFE;
-    y = 64'hB3E00000000007FD;
-    z = 64'h0010000000000001;
-    ans = 64'h34000021000007FB;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4006963\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h434FFFFFFFFFFFFE;
-    z = 64'hB810000000003FFF;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'h3C50003FFFFFC000;
     ans = 64'hC330000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4007577\n");
+    	$fwrite(fp,"1040399\n");
     end
-    x = 64'h470F7FE000000000;
-    y = 64'h47F41FFFFFFFFFFE;
-    z = 64'hB0EFFFFFFFFFFBFF;
-    ans = 64'h4F13CF6BDFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC3E000000FFFFFFC;
+    ReadData2E = 64'hBF8FEFFFFFFFEFFF;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'h437FF0001FEFEFF7;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4008191\n");
+    	$fwrite(fp,"1040705\n");
     end
-    x = 64'h0010000008000FFE;
-    y = 64'h7FE0000000000001;
-    z = 64'h4340000000000001;
-    ans = 64'h4340000000000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'h3CA0000000000001;
+    ans = 64'hC33FFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4008805\n");
+    	$fwrite(fp,"1041011\n");
     end
-    x = 64'hBFD0000000000001;
-    y = 64'h3FE416D104F099D3;
-    z = 64'h37F0000403FFFFFF;
-    ans = 64'hBFC416D104F099D4;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FD00FFFFC000000;
+    ReadData2E = 64'hE76F7B616143C433;
+    ReadData3E = 64'h47F0004000080000;
+    ans = 64'hE74F9ADCBAC62F9F;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4009419\n");
+    	$fwrite(fp,"1041317\n");
     end
-    x = 64'hB3BFFFFFFFFE0007;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'hC020000002000001;
-    ans = 64'hF3BFFFFFFFFE0006;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4010033\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h43C1DB4D2B6309FB;
-    z = 64'hBFE0000000000001;
-    ans = 64'hC3A1DB4D2B6309FC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4010647\n");
-    end
-    x = 64'h4D6FFFFFFD000000;
-    y = 64'h801020000000000F;
-    z = 64'hC02000000007FFFE;
-    ans = 64'hC02000000007FFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4011261\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h7FF0000000000001;
-    z = 64'h3FF0000000000001;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4011875\n");
-    end
-    x = 64'h8390000001FDFFFF;
-    y = 64'h41D00000800001FE;
-    z = 64'h000FFFFFFFFFFFFF;
-    ans = 64'h8570000081FE020D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4012489\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h7FFFFFFFFFFFFFFF;
-    z = 64'hC0303C0000000000;
-    ans = 64'h7FFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4013103\n");
-    end
-    x = 64'h3FB0000000FFFFE0;
-    y = 64'h4D600000020003FE;
-    z = 64'h3FCFFFFA00000000;
-    ans = 64'h4D200000030003DE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4013717\n");
-    end
-    x = 64'hB81FFFC200000000;
-    y = 64'h8000000000000000;
-    z = 64'h401FFFFFFFFFFFFF;
-    ans = 64'h401FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4014331\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hB65BFFFEFFFFFFFF;
-    z = 64'h3F60007FFFFFFFF7;
-    ans = 64'h3F60007FFFFFFFF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4014945\n");
-    end
-    x = 64'h5E7FFFFFFFFFF900;
-    y = 64'h8000000000000001;
-    z = 64'h37FD80E342268EB7;
-    ans = 64'h37FD80E342268EB7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4015559\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h402FFFEFFFFFFFEE;
-    z = 64'hBFDFFFFFFFFFFFFF;
-    ans = 64'hC011FFF7FFFFFFF8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4016173\n");
-    end
-    x = 64'hC342C8CD26F024C5;
-    y = 64'h3F8F6C22FCBDE80E;
-    z = 64'hFFD00000403FFFFE;
-    ans = 64'hFFD00000403FFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4016787\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h8010000000000000;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'h3FEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4017401\n");
-    end
-    x = 64'h000FFFFFFFF03FFE;
-    y = 64'hC03F8000000FFFFE;
-    z = 64'hFFFFFFFFFFFFFFFE;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4018015\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h8010000000000001;
-    z = 64'hBDE04000000001FF;
-    ans = 64'hBDE04000000001FF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4018629\n");
-    end
-    x = 64'hC3E0FFFFFFFFFFF6;
-    y = 64'hC08FFFEFFFF7FFFE;
-    z = 64'hC25FFFFFFDBFFFFF;
-    ans = 64'h4480FFF77FF7BFF5;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4019243\n");
-    end
-    x = 64'h38000000000100FF;
-    y = 64'h801FFFFFFFFFFFFE;
-    z = 64'h400FFFFFFFFFFFFE;
-    ans = 64'h400FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4019857\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hC80FFFFFFFF00003;
-    z = 64'hCAD21510DDD222A9;
-    ans = 64'hCAD21510DDD22269;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4020471\n");
-    end
-    x = 64'h43DFFFFEFFFFFFF8;
-    y = 64'hBCA0000000000000;
-    z = 64'h434FFFFFFFFFFFBF;
-    ans = 64'h434FFFFFFFFFFDBF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4021085\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h402000000020FFFF;
-    z = 64'hBCAFFFFFFFFFFFFE;
-    ans = 64'hC000000000210001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4021699\n");
-    end
-    x = 64'h47F0000000000000;
-    y = 64'hC00FF7FFFFBFFFFE;
-    z = 64'h406001FFFFFFFFF0;
-    ans = 64'hC80FF7FFFFBFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4022313\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h3FDFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4022927\n");
-    end
-    x = 64'hC26FF7FFFFFFFFDF;
-    y = 64'hBE8FFFFFFFFBFFFD;
-    z = 64'hFFF0000000000000;
-    ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4023541\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hBFD0000000000000;
-    z = 64'hB8C00000000020FF;
-    ans = 64'h3FB0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4024155\n");
-    end
-    x = 64'hC08E000003FFFFFF;
-    y = 64'hF9D00000087FFFFE;
-    z = 64'hC02489F7E6A8C0A1;
-    ans = 64'h7A6E000013EFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4024769\n");
-    end
-    x = 64'h43C3E49A1538B476;
-    y = 64'hBFDFFFFFFFFFFFFF;
-    z = 64'h4000000000000000;
-    ans = 64'hC3B3E49A1538B475;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4025383\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hC02FFFFFF7BFFFFF;
-    z = 64'hC01004003FFFFFFE;
-    ans = 64'hBF7001107FFFF600;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4025997\n");
-    end
-    x = 64'h7FEFFFFFFFFEFFBF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'h414FFFFEFFFFBFFF;
-    ans = 64'hFFDFFFFFFFFEFFBD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4026611\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hB52C7FFFFFFFFFFF;
-    z = 64'hBCA0000000000000;
-    ans = 64'hBCA0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4027225\n");
-    end
-    x = 64'h3FAFFFFFF80007FE;
-    y = 64'hBEAFE00000000001;
-    z = 64'h0011FFFFFFFFFFFE;
-    ans = 64'hBE6FDFFFF80807F7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4027839\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h3FD0000000000000;
-    ans = 64'h3FE0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4028453\n");
-    end
-    x = 64'hB80F000000000000;
-    y = 64'h35A00000403FFFFE;
-    z = 64'hFFE0000000000001;
-    ans = 64'hFFE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4029067\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hBFEFFFFFFFFFFFFE;
-    z = 64'hB806C0503D591458;
-    ans = 64'h3FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4029681\n");
-    end
-    x = 64'h401FFC0000000800;
-    y = 64'h6566473ABD074EDC;
-    z = 64'h4047FFFF7FFFFFFE;
-    ans = 64'h65964471D5AFB384;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4030295\n");
-    end
-    x = 64'hBFF0800000000100;
-    y = 64'hBFF0000000000001;
-    z = 64'h3FF0000000000001;
-    ans = 64'h4000400000000081;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4030909\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h648FFFFFC00003FF;
-    z = 64'hD4400000FFFF7FFF;
-    ans = 64'hE46FFFFFC0000401;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4031523\n");
-    end
-    x = 64'hC7F100000000003E;
-    y = 64'hBFFFFFFFFFFFFFFF;
-    z = 64'h3800EFFFFFFFFFFE;
-    ans = 64'h480100000000003D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4032137\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hC1C08FFFFFFFFFFF;
-    z = 64'h8010000000000001;
-    ans = 64'h41A0900000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4032751\n");
-    end
-    x = 64'h3FFFFFFEFFFEFFFF;
-    y = 64'h401003FFFFFDFFFF;
-    z = 64'hC0100FFFFFFF0000;
-    ans = 64'h400FEFFDFF77FF7A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4033365\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hC000000000000001;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3FE0000000000003;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4033979\n");
-    end
-    x = 64'h41C00000001FFBFE;
-    y = 64'hC221001FFFFFFFFE;
-    z = 64'hC34FFFFFFFFFFFFF;
-    ans = 64'hC3F104200021FBFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4034593\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hC00FFFFFFFFFFFFF;
-    z = 64'h7FD00004000FFFFF;
-    ans = 64'h7FD00004000FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4035207\n");
-    end
-    x = 64'hC1C34B4A0CDF34C0;
-    y = 64'h47FFFFFFFFF7FFFE;
-    z = 64'h3FEFFFFFFFFFF03E;
-    ans = 64'hC9D34B4A0CDA61EC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4035821\n");
-    end
-    x = 64'h47FB969279E5DD33;
-    y = 64'hC010000000000000;
-    z = 64'h3FEFFFFFFFFFFFFF;
-    ans = 64'hC81B969279E5DD33;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4036435\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hBFB1C24320BB5D4C;
-    z = 64'hBD6021FFFFFFFFFF;
-    ans = 64'h3F91C24320B9590D;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4037049\n");
-    end
-    x = 64'h3D3000001FEFFFFE;
-    y = 64'hC010000000000001;
-    z = 64'hC2F000000FF00000;
-    ans = 64'hC2F000000FF00000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4037663\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hB7E0000201000000;
-    z = 64'h800FFFFFFFFFFFFF;
-    ans = 64'h37C0000201000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4038277\n");
-    end
-    x = 64'h40500003FFFFFFF7;
-    y = 64'hB81B09507F18BE9F;
-    z = 64'h43100000000000C0;
-    ans = 64'h43100000000000C0;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4038891\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hC340000000000000;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h4320000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4039505\n");
-    end
-    x = 64'h47EFFFE03FFFFFFF;
-    y = 64'h80000800007FFFFF;
-    z = 64'hC01FFFFFFFFFFFFE;
-    ans = 64'hC01FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4040119\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hC340000000000001;
-    z = 64'hBFEFFFFBFEFFFFFF;
-    ans = 64'h4320000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4040733\n");
-    end
-    x = 64'h381000001FF7FFFF;
-    y = 64'hBEFFFFE00000003F;
-    z = 64'h37F00000000407FF;
-    ans = 64'h37EFFF0001061080;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4041347\n");
-    end
-    x = 64'hC00FFE01FFFFFFFF;
-    y = 64'hC34FFFFFFFFFFFFE;
-    z = 64'h3FDFFFFFFFFFFFFE;
-    ans = 64'h436FFE01FFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4041961\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h41DFFFFFFF7FFFFE;
-    z = 64'h3E1FBFFFF0000000;
-    ans = 64'hC1BFFFFFFF800000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4042575\n");
-    end
-    x = 64'hBE5F58FE19AABA16;
-    y = 64'hFFE0000000000000;
-    z = 64'h7B8ABA52ABAF7E78;
-    ans = 64'h7E4F58FE19AABBC2;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4043189\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hB64000004FFFFFFF;
-    z = 64'h7FFFFFFFFFFFFFFE;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4043803\n");
-    end
-    x = 64'hBFF00800000001FF;
-    y = 64'hBEA0000FFFFFFFFF;
-    z = 64'h3CA00000003FFFF7;
-    ans = 64'h3EA00810081001FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4044417\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hFFEFFFFFFFFFFFFE;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'h7FD0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4045031\n");
-    end
-    x = 64'h47F01FFBFFFFFFFF;
-    y = 64'hC3CFFFBFFF000000;
-    z = 64'hC010000000000000;
-    ans = 64'hCBD01FDBBF87001F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4045645\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'hFFF0000000000000;
-    z = 64'hCDF0083FFFFFFFFF;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4046259\n");
-    end
-    x = 64'hC1F0000001FFFFF8;
-    y = 64'hF000091FCAE1C2F2;
-    z = 64'h40700000000FBFFF;
-    ans = 64'h7200091FCCE2E6E3;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4046873\n");
-    end
-    x = 64'h380BFFFFFFFBFFFF;
-    y = 64'hFFFFFFFFFFFFFFFF;
-    z = 64'h3FD0000000000000;
-    ans = 64'hFFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4047487\n");
-    end
-    x = 64'hBFD0000000000001;
-    y = 64'h4F5FFFEFFFFFEFFF;
-    z = 64'hBFEF00FFFFFFFFFF;
-    ans = 64'hCF3FFFEFFFFFF001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4048101\n");
-    end
-    x = 64'h3FCFFFFFFDC00000;
-    y = 64'hFFFFFFFFFFFFFFFE;
-    z = 64'h7FE00000001FFFDF;
-    ans = 64'hFFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4048715\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h3957F80000000000;
-    z = 64'h7FF0000000000000;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4049329\n");
-    end
-    x = 64'h80224267F356EFFA;
-    y = 64'h7FF1000003FFFFFF;
-    z = 64'h401040000000007F;
-    ans = 64'h7FF9000003FFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4049943\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h000FFFFFFFFFFFFF;
-    z = 64'h0000000000000000;
-    ans = 64'h8007FFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4050557\n");
-    end
-    x = 64'h37EFFFBFFFFEFFFF;
-    y = 64'hB7FFDFFFFFFFFEFE;
-    z = 64'hC000000000000001;
-    ans = 64'hC000000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4051171\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h000FFFFFFFFFFFFE;
-    z = 64'h427B3594CB0AE0F1;
-    ans = 64'h427B3594CB0AE0F1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4051785\n");
-    end
-    x = 64'hB8100000037FFFFE;
-    y = 64'h4032B8ACAF198E6B;
-    z = 64'hC1AE1FFFFFFFFFFE;
-    ans = 64'hC1AE1FFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4052399\n");
-    end
-    x = 64'h9EB000000020FFFF;
-    y = 64'h0010000000000001;
-    z = 64'h3CA0000000000001;
-    ans = 64'h3CA0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4053013\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h402325F07518C19F;
-    z = 64'h3FAF0003FFFFFFFF;
-    ans = 64'hC012E7F06D18C19E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4053627\n");
-    end
-    x = 64'hBFC0000000000140;
-    y = 64'h001FFFFFFFFFFFFF;
-    z = 64'h41E0000000000030;
-    ans = 64'h41E0000000000030;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4054241\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'hBF5579030AA5CAAA;
-    z = 64'h7FE0000000000001;
-    ans = 64'h7FE0000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4054855\n");
-    end
-    x = 64'h45BC57DB7A30FEF8;
-    y = 64'hC1FFFFFFFDFFFFBF;
-    z = 64'h41DFFFFFFF800020;
-    ans = 64'hC7CC57DB786B8107;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4055469\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h3CA0000000000000;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4056083\n");
-    end
-    x = 64'h41DFFFFFFFE00001;
-    y = 64'h8000010000100000;
-    z = 64'hBFFFFFFFFFFFFFFF;
-    ans = 64'hBFFFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4056697\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h3CAFFFFFFFFFFFFF;
-    z = 64'h41E000000010007F;
-    ans = 64'h41E000000010007F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4057311\n");
-    end
-    x = 64'h05084F7999D9CDC4;
-    y = 64'hBEBE0D041AA7AD4D;
-    z = 64'h401000007FFFFFFC;
-    ans = 64'h401000007FFFFFFC;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4057925\n");
-    end
-    x = 64'h540FF80200000000;
-    y = 64'h3FD0000000000000;
-    z = 64'h001FFFFFFFFFFFFF;
-    ans = 64'h53EFF80200000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4058539\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'hFFFDE9DA2A5BA63C;
-    z = 64'h479B42C807E21737;
-    ans = 64'hFFFDE9DA2A5BA63C;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4059153\n");
-    end
-    x = 64'h3E2FF7FF00000000;
-    y = 64'h3FD0000000000001;
-    z = 64'hBCAFFFFFBDFFFFFF;
-    ans = 64'h3E0FF7FE8000010A;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4059767\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h001000200000000E;
-    z = 64'h434FFFFFFFFFFFFF;
-    ans = 64'h434FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4060381\n");
-    end
-    x = 64'hC3CFDFFFFFFFFFFB;
-    y = 64'h401FFFFF800003FF;
-    z = 64'h3FFC31B98FE49BD5;
-    ans = 64'hC3FFDFFF808003F6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4060995\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h3FDFFFFFFFFFFFFE;
-    z = 64'hFFEFFFFFFFFFFFFF;
-    ans = 64'hFFEFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4061609\n");
-    end
-    x = 64'hBFEFFFFFFFC00040;
-    y = 64'h37FFFFFFF80000FE;
-    z = 64'hBFEFFFFFFFFFFFFE;
-    ans = 64'hBFEFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4062223\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h3FE0000000000001;
-    z = 64'hC0100007FFFFEFFF;
-    ans = 64'hC0110007FFFFEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4062837\n");
-    end
-    x = 64'hFFEFFFFE007FFFFF;
-    y = 64'hBFF00000040FFFFF;
-    z = 64'hC1A12616CF13226C;
-    ans = 64'h7FEFFFFE089FFF7B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4063451\n");
-    end
-    x = 64'hD3744789209EB713;
-    y = 64'h3FEFFFFFFFFFFFFE;
-    z = 64'h000FFFFFFFFFFFFE;
-    ans = 64'hD3744789209EB712;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4064065\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h802FFFFFFBFFFFF7;
-    z = 64'hC030001FFFFFFFFF;
-    ans = 64'hC030001FFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4064679\n");
-    end
-    x = 64'h43FFFFBFFFFF7FFF;
-    y = 64'h3FF0000000000000;
-    z = 64'hBAD007FFC0000000;
-    ans = 64'h43FFFFBFFFFF7FFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4065293\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h401F000000001FFF;
-    z = 64'h401FFFFFFFFFFFFE;
-    ans = 64'h40107FFFFFFFEFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4065907\n");
-    end
-    x = 64'h3CAFFFAFFFFFFFFF;
-    y = 64'h40C8BC8C8EDD1A1B;
-    z = 64'hBA8BBCC16EDFA2A4;
-    ans = 64'h3D88BC4EB77DB4D6;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4066521\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h3FFFFFFFFFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFE;
-    ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4067135\n");
-    end
-    x = 64'h480007FFFFFFFFFF;
-    y = 64'hC3E23B89425430FF;
-    z = 64'hBFE0000000000000;
-    ans = 64'hCBF244A706F55B16;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4067749\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h4000000000000000;
-    z = 64'hC80C200000000000;
-    ans = 64'hC80C200000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4068363\n");
-    end
-    x = 64'hC3D000003FFFFFFA;
-    y = 64'hC001FBFFFFFFFFFF;
-    z = 64'hC3DFFFFF000003FE;
-    ans = 64'h43AFC00C7EFFDF94;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4068977\n");
-    end
-    x = 64'hCDA0007FFFFF7FFE;
-    y = 64'h400FFFFFFFFFFFFF;
-    z = 64'h0000000000000000;
-    ans = 64'hCDC0007FFFFF7FFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4069591\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'hB7E0000007FDFFFF;
-    z = 64'hF06BFFFFFFFFFDFF;
-    ans = 64'hF06BFFFFFFFFFDFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4070205\n");
-    end
-    x = 64'h3FC6375007C0E6CB;
-    y = 64'h400FFFFFFFFFFFFE;
-    z = 64'hBF80100200000000;
-    ans = 64'h3FE5F70FFFC0E6CA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4070819\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h3F800000000000FF;
-    z = 64'h4010000000000000;
-    ans = 64'h400FF80000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4071433\n");
-    end
-    x = 64'hC2F505134A57C74A;
-    y = 64'hC4FDFFFDFFFFFFFE;
-    z = 64'h00036DB98B6B20DE;
-    ans = 64'h4803B4C0C561162F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4072047\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h4010000000000001;
-    z = 64'hC340000000000000;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h33E000FFFFFFFDFF;
+    ReadData3E = 64'hC340000000000001;
     ans = 64'hC340000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4072661\n");
+    	$fwrite(fp,"1041623\n");
     end
-    x = 64'hC1D000001003FFFE;
-    y = 64'hE41628388A474A48;
-    z = 64'hBFD0000000000001;
-    ans = 64'h65F62838A0750CDE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hFFFFFFEFFFFF7FFF;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'hC03001FFFFFFFFFE;
+    ans = 64'hFFFFFFEFFFFF7FFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4073275\n");
+    	$fwrite(fp,"1041929\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h401FFFFFFFFFFFFE;
-    z = 64'hBFBD1E150B87BBA9;
-    ans = 64'hC0107478542E1EED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBACFFBFDFFFFFFFF;
+    ReadData3E = 64'hC00007FFFFF7FFFE;
+    ans = 64'hC00007FFFFF7FFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4073889\n");
+    	$fwrite(fp,"1042235\n");
     end
-    x = 64'h403000080000FFFF;
-    y = 64'hC11FFFFFFFFF7FBF;
-    z = 64'h3FD0000007FFF000;
-    ans = 64'hC1600007F800BFDA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4074503\n");
-    end
-    x = 64'h402442B011FC172E;
-    y = 64'h4340000000000000;
-    z = 64'hFFF0000000000001;
-    ans = 64'hFFF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4075117\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h92E5F946438B34BB;
-    z = 64'h3D98249F431F8AF7;
-    ans = 64'h3D98249F431F8AF7;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4075731\n");
-    end
-    x = 64'h7FFD8D2187349BAF;
-    y = 64'h434FFFFFFFFFFFFF;
-    z = 64'hBFAFFFFFEFFFFFEF;
-    ans = 64'h7FFD8D2187349BAF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4076345\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h403FE01FFFFFFFFE;
-    z = 64'h4000000000000001;
-    ans = 64'hC02BE01FFFFFFFFD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4076959\n");
-    end
-    x = 64'hB61FF07FFFFFFFFE;
-    y = 64'hC1F1BFFFFFFFFFFF;
-    z = 64'h9EE00007FFFFFDFE;
-    ans = 64'h3821B766FFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4077573\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h7FE0000000000000;
-    z = 64'hC010000000000001;
-    ans = 64'hFFCFFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4078187\n");
-    end
-    x = 64'h402FFFDFFFFFFFF0;
-    y = 64'h42B0000000204000;
-    z = 64'hBCAFFFFFFFFFFFFF;
-    ans = 64'h42EFFFE000407FAF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4078801\n");
-    end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h7FEFFFFFFFFFFFFF;
-    z = 64'h3FF2000007FFFFFF;
-    ans = 64'hFFDFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4079415\n");
-    end
-    x = 64'hBFBFFFFFFFFFFFC4;
-    y = 64'h001FFF4000000000;
-    z = 64'h3FFFFFBFFF7FFFFF;
-    ans = 64'h3FFFFFBFFF7FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
-#10
-    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
-    //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
-	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
-		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
-		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
-		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4080029\n");
-    end
-    x = 64'hBFC3F41B293A86D3;
-    y = 64'h7FEFFFFFFFFFFFFE;
-    z = 64'hFFEFFFFFFFFFFFFF;
+    ReadData1E = 64'h4060803FFFFFFFFF;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
     ans = 64'hFFF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4080643\n");
+    	$fwrite(fp,"1042541\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'hC0D1AADED1EB7CD5;
-    z = 64'hBFD007FFFFFDFFFE;
-    ans = 64'h40C1AABEC1EB7CD8;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FF040000000000F;
+    ReadData2E = 64'hC1FFFFFF7FFFFFF0;
+    ReadData3E = 64'h570000007FC00000;
+    ans = 64'h570000007FC00000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4081257\n");
+    	$fwrite(fp,"1042847\n");
     end
-    x = 64'h7FEFFFFFFFF7EFFE;
-    y = 64'h7FF0000000000001;
-    z = 64'hC1FFFF7FFFFFFFFF;
-    ans = 64'h7FF8000000000001;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'hC7EFFFFFFEFFFDFF;
+    ans = 64'hFFCFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4081871\n");
+    	$fwrite(fp,"1043153\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'hC05FFFFFFFE7FFFF;
-    z = 64'h3FFFFFFFFFFFFFFF;
-    ans = 64'h40507FFFFFF3FFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBFEFEFFFBFFFFFFE;
+    ReadData2E = 64'hA15FF00000000100;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h3FE0000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4082485\n");
+    	$fwrite(fp,"1043459\n");
     end
-    x = 64'h7FEF0001FFFFFFFF;
-    y = 64'h5E388880C29ADC6B;
-    z = 64'hBFC05BC428DD59D2;
-    ans = 64'h7FF0000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'h801FFFFFFFFFFFFF;
+    ans = 64'hFFD0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4083099\n");
+    	$fwrite(fp,"1043765\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h7FFFFFFFFFFFFFFE;
-    z = 64'hC00FFFFFFFFFFFFF;
-    ans = 64'h7FFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBDE0A431843E6962;
+    ReadData2E = 64'hC007BF7F4F6FE319;
+    ReadData3E = 64'h7FD0000000002200;
+    ans = 64'h7FD0000000002200;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4083713\n");
+    	$fwrite(fp,"1044071\n");
     end
-    x = 64'h43FFFFFEFFFFFFDF;
-    y = 64'h3FD04007FFFFFFFE;
-    z = 64'h801FFFFFFFFFFFFE;
-    ans = 64'h43E040077DFFBFED;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC7E311181221223D;
+    ReadData3E = 64'h401FFFFFFFFFFFFF;
+    ans = 64'hC7D311181221223C;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4084327\n");
+    	$fwrite(fp,"1044377\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h8000000000000001;
-    z = 64'h8010000000800400;
-    ans = 64'h8010000000800400;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h60CC008000000000;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hBFDAB06782893A16;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4084941\n");
+    	$fwrite(fp,"1044683\n");
     end
-    x = 64'h43D00000000000BF;
-    y = 64'hF9FCA451E6B538F5;
-    z = 64'hCD0EA8DC36585668;
-    ans = 64'hFDDCA451E6B53A4B;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hC00FFFE000000002;
+    ReadData3E = 64'hBFDFFFFFFFFFF00F;
+    ans = 64'hC003FFEFFFFFFE02;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4085555\n");
+    	$fwrite(fp,"1044989\n");
     end
-    x = 64'h40600001FF000000;
-    y = 64'h800FFFFFFFFFFFFF;
-    z = 64'hC34FFFFFFFFFFFFE;
+    ReadData1E = 64'h4040000000101FFE;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1045295\n");
+    end
+    ReadData1E = 64'h41C0EE6217580667;
+    ReadData2E = 64'hFFEFFFFFF7FFFFFC;
+    ReadData3E = 64'h3FF2E298683C3F2D;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1045601\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'h450FFFFFFFFFFFFF;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1045907\n");
+    end
+    ReadData1E = 64'h380FFDFFFFFDFFFF;
+    ReadData2E = 64'hC3F0FFFFFFFFFEFE;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hBFDFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1046213\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'h000FFFFFFFFFFFFE;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1046519\n");
+    end
+    ReadData1E = 64'hBFDFFEFFEFFFFFFE;
+    ReadData2E = 64'hBFDCAB6630300A64;
+    ReadData3E = 64'hC1DFFBFFFFFFE000;
+    ans = 64'hC1DFFBFFFFF18AC0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1046825\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hBFFFFF3FFFFFFFFF;
+    ReadData3E = 64'hC00FFFFFFFFFFFFE;
+    ans = 64'hC013FFE7FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1047131\n");
+    end
+    ReadData1E = 64'hFFD0080000007FFE;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h480ECB8DF4D61707;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1047437\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'h002FFFFFFFFFFFFF;
+    ReadData3E = 64'h4944C0B502DF4D9E;
+    ans = 64'h4944C0B502DF4D9E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1047743\n");
+    end
+    ReadData1E = 64'hBCBFC01000000000;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1048049\n");
+    end
+    ReadData1E = 64'hC2AFFFFFFFFFFFFF;
+    ReadData2E = 64'hBDFBFFFFFFFFFF7F;
+    ReadData3E = 64'hBF83698EAB72255D;
+    ans = 64'h40BBFFFD92CE2A10;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1048355\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h801A50D4FC9D3CC9;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1048661\n");
+    end
+    ReadData1E = 64'hBF94D8272D1C6FD0;
+    ReadData2E = 64'hBF8FFFFFFFFFF0FF;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h3F34D8272D1C760A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1048967\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'h8000000000000000;
+    ans = 64'h0000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1049273\n");
+    end
+    ReadData1E = 64'h3F00000000100010;
+    ReadData2E = 64'h5E5BFFFFFFFFEFFF;
+    ReadData3E = 64'hBFDFF00007FFFFFE;
+    ans = 64'h5D6C0000001BF01B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1049579\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFC0000009FFFFFF;
+    ReadData3E = 64'h4000000000000000;
+    ans = 64'h3FFEFFFFFF600000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1049885\n");
+    end
+    ReadData1E = 64'hB7FDFBFFFFFFFFFE;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'h7FD000000000203F;
+    ans = 64'h7FD000000000203F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1050191\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h434FFFFFFFE0001F;
+    ReadData3E = 64'hBFFFFEFFFF7FFFFF;
+    ans = 64'h433FFFFFFFE0001B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1050497\n");
+    end
+    ReadData1E = 64'hC0C00000400001FF;
+    ReadData2E = 64'h000FFFFFFFFFFFFF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1050803\n");
+    end
+    ReadData1E = 64'h4BC0040000003FFF;
+    ReadData2E = 64'h41DFE0000000FFFF;
+    ReadData3E = 64'h3FC0000FFFFFFFFF;
+    ans = 64'h4DAFE7F800017FBD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1051109\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FDFFFFFF000001E;
+    ans = 64'h7FDFFFFFF000001E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1051415\n");
+    end
+    ReadData1E = 64'h3FC0000001000010;
+    ReadData2E = 64'hBFF5BD425B6267A3;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hBFC5BD425CBE3BE2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1051721\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h000FFFFFFFFFFFFE;
+    ReadData3E = 64'hFFF0000000000001;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1052027\n");
+    end
+    ReadData1E = 64'h52FFFFF801FFFFFF;
+    ReadData2E = 64'h3D30000000007FFF;
+    ReadData3E = 64'hBFE1B8A4DD23031A;
+    ans = 64'h503FFFF80200FFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1052333\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFE14F5BF1948F88;
+    ReadData3E = 64'hBFF0000000000001;
+    ans = 64'hBFF453D6FC6523E3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1052639\n");
+    end
+    ReadData1E = 64'h40096DFEA6B9CF4D;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'hC3C2000000000040;
+    ans = 64'hC3C2000000000040;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1052945\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3F00000020080000;
+    ReadData3E = 64'h000BF714D245ED69;
+    ans = 64'h3EF000002007FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1053251\n");
+    end
+    ReadData1E = 64'hC93FFFFFFBFFEFFF;
+    ReadData2E = 64'h0010000000000001;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
     ans = 64'hC34FFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4086169\n");
+    	$fwrite(fp,"1053557\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h4030000000FFFFFB;
-    z = 64'h3CAFEFFFFFFFFDFF;
-    ans = 64'hC020000000FFFFFA;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h5ED64804F957BD63;
+    ReadData2E = 64'h7FEA233C26339EFB;
+    ReadData3E = 64'hC7E79C84C2D4C3CC;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4086783\n");
+    	$fwrite(fp,"1053863\n");
     end
-    x = 64'h001FFBFFFFFFFFFB;
-    y = 64'h8010000000000000;
-    z = 64'hBFA00FDFFFFFFFFF;
-    ans = 64'hBFA00FDFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h001FFFFFFFFFFFFF;
+    ReadData3E = 64'h353FDF8000000000;
+    ans = 64'h353FDF8000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4087397\n");
+    	$fwrite(fp,"1054169\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h3F900000000EFFFF;
-    z = 64'h3FEFFFFFFFFFFFFE;
-    ans = 64'h3FEFBFFFFFFFC3FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC1EFFFFFFBF80000;
+    ReadData2E = 64'h4050000000000000;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'hC24FFFFFFBF80000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4088011\n");
+    	$fwrite(fp,"1054475\n");
     end
-    x = 64'h8005FBF65B4CBC10;
-    y = 64'h41D0015FA92DD7E1;
-    z = 64'h4EBFFFFFFE000002;
-    ans = 64'h4EBFFFFFFE000002;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h001FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFF;
+    ans = 64'h7FEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4088625\n");
+    	$fwrite(fp,"1054781\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h801FFFFFFFFFFFFF;
-    z = 64'hBFFFFFFFFFFFFFFE;
-    ans = 64'hBFFFFFFFFFFFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h41D4C6B47A165676;
+    ReadData2E = 64'hBEEFFFFFFFFFFEFE;
+    ReadData3E = 64'hC027ABDD993EECCF;
+    ans = 64'hC0D4C9A9F5C97DAC;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4089239\n");
+    	$fwrite(fp,"1055087\n");
     end
-    x = 64'hBD7000000000207F;
-    y = 64'h8EA0080000001000;
-    z = 64'h8010000000000000;
-    ans = 64'h0C2008000000308F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFFAB60866FB2019;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFF;
+    ans = 64'h3FC527DE64137F9F;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4089853\n");
+    	$fwrite(fp,"1055393\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'hBCA0000000000000;
-    z = 64'h80166B3DD617F693;
-    ans = 64'h3C8FFFFFFFFFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDEFFF7FFFFFFFE;
+    ReadData2E = 64'h3CA0000000000000;
+    ReadData3E = 64'h3FBFF7FFFFFC0000;
+    ans = 64'h3FBFF7FFFFFC0004;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4090467\n");
+    	$fwrite(fp,"1055699\n");
     end
-    x = 64'hB81DAC55BF5BDFB4;
-    y = 64'hDCC38871CC23B0AF;
-    z = 64'h3CA0000007DFFFFF;
-    ans = 64'h54F21CD8DBE659FE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h38103FFFFFFFFFDF;
+    ReadData3E = 64'hC800020000000000;
+    ans = 64'hC800020000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4091081\n");
+    	$fwrite(fp,"1056005\n");
     end
-    x = 64'hA15FFFFFFF001FFF;
-    y = 64'hBCA0000000000001;
-    z = 64'hC340000000000000;
+    ReadData1E = 64'h3FB000000010007F;
+    ReadData2E = 64'h3CA0000000000001;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h4340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1056311\n");
+    end
+    ReadData1E = 64'hC06FFFFFFEF00000;
+    ReadData2E = 64'hBCA3F00000000000;
+    ReadData3E = 64'hC1D659022B8CF3A6;
+    ans = 64'hC1D659022B8CF3A6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1056617\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'hFFE80000000000FF;
+    ans = 64'hFFE80000000000FF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1056923\n");
+    end
+    ReadData1E = 64'hBE5FFFFE0000007E;
+    ReadData2E = 64'hBFFFF8000007FFFE;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'h3E6FF7FE0088007B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1057229\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3CAFFFFFFFFFFFFF;
+    ReadData3E = 64'hC34FFFFFFFFFFFFE;
+    ans = 64'hC34FFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1057535\n");
+    end
+    ReadData1E = 64'hBFFFFE000000003F;
+    ReadData2E = 64'hE5CC78B61B1FB3DF;
+    ReadData3E = 64'h7FEFFFFE00000001;
+    ans = 64'h7FEFFFFE00000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1057841\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hB52FFFFFFF0FFFFF;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFE;
+    ans = 64'hBFDFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1058147\n");
+    end
+    ReadData1E = 64'hC3DFFFFFA0000000;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'h40B00003FFFFFFE0;
+    ans = 64'hC3BFFFFF9FFFFFF0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1058453\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC030D5C41923E3C4;
+    ReadData3E = 64'h3FE080FFFFFFFFFF;
+    ans = 64'hC01F9B683247C786;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1058759\n");
+    end
+    ReadData1E = 64'hC18FFFBFE0000000;
+    ReadData2E = 64'h3FD0000000000000;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC16FFFC060000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1059065\n");
+    end
+    ReadData1E = 64'hC05F800007FFFFFE;
+    ReadData2E = 64'hBCB0000002200000;
+    ReadData3E = 64'h7FD000FFFFFFFFFF;
+    ans = 64'h7FD000FFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1059371\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FD0000000000001;
+    ReadData3E = 64'hC3CFFFFFEFFFFFFC;
+    ans = 64'hC3CFFFFFEFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1059677\n");
+    end
+    ReadData1E = 64'hC34FFDFFFFFFF000;
+    ReadData2E = 64'hC0621FFFFFFFFFFF;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1059983\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFF;
+    ReadData3E = 64'h4340000000000000;
+    ans = 64'h4340000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1060289\n");
+    end
+    ReadData1E = 64'h3B20000207FFFFFF;
+    ReadData2E = 64'h802000800000001F;
+    ReadData3E = 64'h3E804000000000FE;
+    ans = 64'h3E804000000000FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1060595\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h43403FFFFFFFDFFE;
+    ReadData3E = 64'h3FD0000000000000;
+    ans = 64'h43303FFFFFFFDFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1060901\n");
+    end
+    ReadData1E = 64'hBBAFFFFC7FFFFFFE;
+    ReadData2E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FFF800007FFFFFE;
+    ans = 64'h7FFF800007FFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1061207\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h37BFE0003FFFFFFF;
+    ReadData3E = 64'h3F700000200007FE;
+    ans = 64'h3F700000200007FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1061513\n");
+    end
+    ReadData1E = 64'hBFCFFFEDFFFFFFFF;
+    ReadData2E = 64'h3FE0000000000000;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h400F00008FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1061819\n");
+    end
+    ReadData1E = 64'h3FA000001FFFFFE0;
+    ReadData2E = 64'hBEA0020000001FFF;
+    ReadData3E = 64'h40EFFFFFFFFFFFE7;
+    ans = 64'h40EFFFFFFFFFF7E6;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1062125\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'hC02FFFFF000007FE;
+    ans = 64'hC02F7FFF000007FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1062431\n");
+    end
+    ReadData1E = 64'hC03BE7FA8F940E1A;
+    ReadData2E = 64'hC7FFBFFFFFFFDFFF;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1062737\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FE0000000000001;
+    ReadData3E = 64'hC010000000000001;
+    ans = 64'hC00E000000000002;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1063043\n");
+    end
+    ReadData1E = 64'h7FF6F884134124A3;
+    ReadData2E = 64'h1124345EB2F9D7C2;
+    ReadData3E = 64'h3FF093DCB192A945;
+    ans = 64'h7FFEF884134124A3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1063349\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC44FFFEFFFFBFFFE;
+    ReadData3E = 64'hBCA0000000000001;
+    ans = 64'hC43FFFEFFFFBFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1063655\n");
+    end
+    ReadData1E = 64'h43F000FFFF7FFFFF;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FC08000007FFFFF;
+    ans = 64'h43F000FFFF7FFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1063961\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3D7FFFC001FFFFFE;
+    ReadData3E = 64'h7FE2742ED7A37446;
+    ans = 64'h7FE2742ED7A37446;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1064267\n");
+    end
+    ReadData1E = 64'hC02003FFE0000000;
+    ReadData2E = 64'h3FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hC02403FFDFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1064573\n");
+    end
+    ReadData1E = 64'h432A1E70319EA668;
+    ReadData2E = 64'hC3C00000000000EF;
+    ReadData3E = 64'hFFDFFFFBFFFFFFFC;
+    ans = 64'hFFDFFFFBFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1064879\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FF0000000000000;
+    ReadData3E = 64'hC08EAC5CED022B82;
+    ans = 64'hC08EA85CED022B82;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1065185\n");
+    end
+    ReadData1E = 64'hBFC01AA92E0FD347;
+    ReadData2E = 64'h43DBFFDFFFFFFFFF;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1065491\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FF0000000000001;
+    ReadData3E = 64'h400FFFFFFFFFFFFF;
+    ans = 64'h4011FFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1065797\n");
+    end
+    ReadData1E = 64'hC0C08000000003FF;
+    ReadData2E = 64'hC1DFFFF3FFFFFFFE;
+    ReadData3E = 64'h41F9C64E718456C2;
+    ans = 64'h42B0819634E71C43;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1066103\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h4465F3D65FF408DD;
+    ReadData3E = 64'h001FFFFFFFFFFFFF;
+    ans = 64'h4455F3D65FF408DC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1066409\n");
+    end
+    ReadData1E = 64'hB58FEFFC00000000;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFF;
+    ReadData3E = 64'hBE600FFFF8000000;
+    ans = 64'hBE600FFFF8000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1066715\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h403000000010000F;
+    ReadData3E = 64'h7FD0001FDFFFFFFF;
+    ans = 64'h7FD0001FDFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1067021\n");
+    end
+    ReadData1E = 64'hB810002000000000;
+    ReadData2E = 64'h3FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h3FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1067327\n");
+    end
+    ReadData1E = 64'h443FFFF800020000;
+    ReadData2E = 64'h232BFFFFFFFFF7FF;
+    ReadData3E = 64'hF7EFFFFFFF87FFFF;
+    ans = 64'hF7EFFFFFFF87FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1067633\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'hC01806C8304C3CA3;
+    ans = 64'hC01406C8304C3CA3;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1067939\n");
+    end
+    ReadData1E = 64'h40200007FFFFFFBF;
+    ReadData2E = 64'h43FFFFFFFFFFFF5F;
+    ReadData3E = 64'h434FFFFFFFFFFFFF;
+    ans = 64'h44300047FFFFFF6E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1068245\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h4000000000000000;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFE;
+    ans = 64'hBFEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1068551\n");
+    end
+    ReadData1E = 64'h417000000001001E;
+    ReadData2E = 64'hB4F1BB57032E8670;
+    ReadData3E = 64'hBFEFFFFFFFFF9FFF;
+    ans = 64'hBFEFFFFFFFFF9FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1068857\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC8048B8D53C7F5BB;
+    ReadData3E = 64'h800FFFFFFFFFFFFE;
+    ans = 64'hC7F48B8D53C7F5BA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1069163\n");
+    end
+    ReadData1E = 64'hC01FFFFFFFFEFFF7;
+    ReadData2E = 64'h4000000000000001;
+    ReadData3E = 64'hBE4E000FFFFFFFFF;
+    ans = 64'hC0300000003B801C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1069469\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h7FE1000000007FFF;
+    ReadData3E = 64'hC01F8000000001FE;
+    ans = 64'h7FD1000000007FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1069775\n");
+    end
+    ReadData1E = 64'h41EFFFFFFEFFFFBE;
+    ReadData2E = 64'h400FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'h420FFFFFFEFBFFBD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1070081\n");
+    end
+    ReadData1E = 64'hC18000000F000000;
+    ReadData2E = 64'h488000000000FFFE;
+    ReadData3E = 64'h41C010003FFFFFFE;
+    ans = 64'hCA1000000F00FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1070387\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h400FFFFFFFFFFFFE;
+    ReadData3E = 64'hB7E9007C3CE5D513;
+    ans = 64'h3FFFFFFFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1070693\n");
+    end
+    ReadData1E = 64'h002FFFFFFFFFF006;
+    ReadData2E = 64'hFFF8A6F40A830B75;
+    ReadData3E = 64'hC01FFFFFFFFFFFFE;
+    ans = 64'hFFF8A6F40A830B75;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1070999\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h4010000000000000;
+    ReadData3E = 64'h3FF0000000000000;
+    ans = 64'h4007FFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1071305\n");
+    end
+    ReadData1E = 64'hC03000100FFFFFFF;
+    ReadData2E = 64'h381FFFC00000003F;
+    ReadData3E = 64'hBCA0200000004000;
+    ans = 64'hBCA0200000004000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1071611\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h710FF1FFFFFFFFFE;
+    ReadData3E = 64'h0000000000000000;
+    ans = 64'h70FFF1FFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1071917\n");
+    end
+    ReadData1E = 64'h47F0FFF7FFFFFFFE;
+    ReadData2E = 64'h4010000000000001;
+    ReadData3E = 64'hB7E0000000000060;
+    ans = 64'h4810FFF7FFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1072223\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC3D0000001FFDFFF;
+    ReadData3E = 64'h400FFBFFFF7FFFFF;
+    ans = 64'hC3C0000001FFDFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1072529\n");
+    end
+    ReadData1E = 64'hC4B53D377B80B5C0;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'hC4E53D377B80B5BF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1072835\n");
+    end
+    ReadData1E = 64'hBFAB3C37F3B44C72;
+    ReadData2E = 64'h3801000004000000;
+    ReadData3E = 64'hC00FFFFF6FFFFFFE;
+    ans = 64'hC00FFFFF6FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1073141\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h401FFFFFFFFFFFFF;
+    ReadData3E = 64'hBE3F0000000FFFFF;
+    ans = 64'h400FFFFFFF07FFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1073447\n");
+    end
+    ReadData1E = 64'hC39FFFFFFBFFFDFF;
+    ReadData2E = 64'h4770000002080000;
+    ReadData3E = 64'h4010000000000000;
+    ans = 64'hCB2000000007FEFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1073753\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h401FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFE0000000000001;
+    ans = 64'h400BFFFFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1074059\n");
+    end
+    ReadData1E = 64'h419000001FFFFEFF;
+    ReadData2E = 64'h471FFC95BD9A3D25;
+    ReadData3E = 64'h37EF600000000000;
+    ans = 64'h48BFFC95FD93669E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1074365\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFD000009FFFFFFF;
+    ReadData3E = 64'h7FF0000000000001;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1074671\n");
+    end
+    ReadData1E = 64'h47EFE1FFFFFFFFFE;
+    ReadData2E = 64'h4340000000000000;
+    ReadData3E = 64'hC00FFFFFFF03FFFE;
+    ans = 64'h4B3FE1FFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1074977\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hB77565980E71074C;
+    ReadData3E = 64'hC07AEC57F394DD51;
+    ans = 64'hC07AEC57F394DD51;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1075283\n");
+    end
+    ReadData1E = 64'h3FB7EA8EA0DB9F94;
+    ReadData2E = 64'h4340000000000001;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'h4307EA8EA0DB9F95;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1075589\n");
+    end
+    ReadData1E = 64'h400FFFFFFE007FFE;
+    ReadData2E = 64'h711400000FFFFFFF;
+    ReadData3E = 64'h43E57BE412E34D74;
+    ans = 64'h713400000EC04FFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1075895\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h434FFFFFFFFFFFFF;
+    ReadData3E = 64'hC1CEFFFEFFFFFFFF;
+    ans = 64'h433FFFFFC20001FD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1076201\n");
+    end
+    ReadData1E = 64'h3FFFFFFFFFFFBFFC;
+    ReadData2E = 64'hC3C60616C794210B;
+    ReadData3E = 64'hC000000000000001;
+    ans = 64'hC3D60616C793F4FC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1076507\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h434FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FDFFFFFFFFFFFFF;
+    ans = 64'h433FFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1076813\n");
+    end
+    ReadData1E = 64'hC1EDFFFFF7FFFFFE;
+    ReadData2E = 64'h540FFFFFFC003FFF;
+    ReadData3E = 64'h3E5FEFFBFFFFFFFF;
+    ans = 64'hD60DFFFFF4403BFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1077119\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC9700003FFDFFFFF;
+    ReadData3E = 64'hFFEFFFFFFFFFFFFF;
+    ans = 64'hFFEFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1077425\n");
+    end
+    ReadData1E = 64'h3FBFFFFFFFFFF01F;
+    ReadData2E = 64'h7FE0000000000000;
+    ReadData3E = 64'hC026694A871241A8;
+    ans = 64'h7FAFFFFFFFFFF01F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1077731\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FCBFFFFBFFFFFFF;
+    ReadData3E = 64'h40AFF7FFFEFFFFFF;
+    ans = 64'h40AFF837FEFF7FFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1078037\n");
+    end
+    ReadData1E = 64'hC00FFFFFFEE00000;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1078343\n");
+    end
+    ReadData1E = 64'h3FB0000001EFFFFE;
+    ReadData2E = 64'h80100000007FFFFE;
+    ReadData3E = 64'h41E0FF7FFFFFFFFE;
+    ans = 64'h41E0FF7FFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1078649\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h7FE0000000000001;
+    ReadData3E = 64'h41D007FFFFDFFFFF;
+    ans = 64'h7FD0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1078955\n");
+    end
+    ReadData1E = 64'h17C00000000800FE;
+    ReadData2E = 64'h3FEFFFFFFFFFFE00;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFF;
+    ans = 64'h3FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1079261\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFF;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFE;
+    ans = 64'h7FDFFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1079567\n");
+    end
+    ReadData1E = 64'h43CF7FFFFFFF8000;
+    ReadData2E = 64'hBFBB9EDE467471F8;
+    ReadData3E = 64'h4893FFFFFFFFFFFF;
+    ans = 64'h4893FFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1079873\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h43C2B9FEFACE0877;
+    ReadData3E = 64'h434FFFFFFFFFFFFE;
+    ans = 64'h43B2F9FEFACE0876;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1080179\n");
+    end
+    ReadData1E = 64'h43EDD3E4302B9937;
+    ReadData2E = 64'h7FEFFFFFFFFFFFFE;
+    ReadData3E = 64'hB7E8380CF656C23A;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1080485\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBCA7BFFFFFFFFFFF;
+    ReadData3E = 64'h399FFFF7FFFFF7FF;
+    ans = 64'hBC97BFFFFFFFFFDE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1080791\n");
+    end
+    ReadData1E = 64'hBFCFFFFFFFF00000;
+    ReadData2E = 64'h7FF0000000000000;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1081097\n");
+    end
+    ReadData1E = 64'hBF872FE583CF2298;
+    ReadData2E = 64'h3CA2BBA100BAE285;
+    ReadData3E = 64'hC35FF7FFFFFEFFFE;
+    ans = 64'hC35FF7FFFFFEFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1081403\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h7FF0000000000001;
+    ReadData3E = 64'h429B13F3D64F1831;
+    ans = 64'h7FF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1081709\n");
+    end
+    ReadData1E = 64'hBFB00001003FFFFE;
+    ReadData2E = 64'h41CFFFE000000001;
+    ReadData3E = 64'hBFEFFFFFFFFFFFFE;
+    ans = 64'hC18FFFE2087DFF7D;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1082015\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFF;
+    ReadData3E = 64'h3CA0000000000000;
+    ans = 64'h7FFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1082321\n");
+    end
+    ReadData1E = 64'h200DA806045D23E7;
+    ReadData2E = 64'hBFDFFE0010000000;
+    ReadData3E = 64'hC1500001BFFFFFFF;
+    ans = 64'hC1500001BFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1082627\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3FD03FFFFFFFFFFF;
+    ReadData3E = 64'hC340000000000000;
     ans = 64'hC340000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4091695\n");
+    	$fwrite(fp,"1082933\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h0000000000000088;
-    z = 64'hF9B000007FDFFFFF;
-    ans = 64'hF9B000007FDFFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3800000008003FFF;
+    ReadData2E = 64'h7FFFFFFFFFFFFFFE;
+    ReadData3E = 64'h41D00008000001FF;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4092309\n");
+    	$fwrite(fp,"1083239\n");
     end
-    x = 64'h43E00001F7FFFFFF;
-    y = 64'hBCAFFFFFFFFFFFFE;
-    z = 64'hB9E00000001FFFBF;
-    ans = 64'hC0A00001F7FFFFFE;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h37E000000007BFFE;
+    ReadData3E = 64'h3CAFF00003FFFFFF;
+    ans = 64'h3CAFF00003FFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4092923\n");
+    	$fwrite(fp,"1083545\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h541FFFFFFE0001FE;
-    z = 64'h3FE0000000000000;
-    ans = 64'hD40FFFFFFE0001FD;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hBEAF80000000001E;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h000FFFFFFFFFFFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4093537\n");
+    	$fwrite(fp,"1083851\n");
     end
-    x = 64'h39700004000007FE;
-    y = 64'h3800000800400000;
-    z = 64'h3FDB4AD36E04AA09;
-    ans = 64'h3FDB4AD36E04AA09;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3805456CE15D5053;
+    ReadData2E = 64'h5E8000020001FFFF;
+    ReadData3E = 64'h7470000000FFEFFF;
+    ans = 64'h7470000000FFEFFF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4094151\n");
+    	$fwrite(fp,"1084157\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'hBFD0000000000001;
-    z = 64'hBFF0000000000000;
-    ans = 64'hBFEC000000000000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h8000000000000000;
+    ReadData3E = 64'h40300000002003FF;
+    ans = 64'h40300000002003FF;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4094765\n");
+    	$fwrite(fp,"1084463\n");
     end
-    x = 64'h43EFFFFE0000000E;
-    y = 64'hBFEFFFFFFFFFFE07;
-    z = 64'h8000000000000001;
-    ans = 64'hC3EFFFFDFFFFFE15;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hABEBA5B21AB91F03;
+    ReadData2E = 64'hC3A8E57EF02FF6AE;
+    ReadData3E = 64'h3FE0000000000000;
+    ans = 64'h3FE0000000000000;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4095379\n");
+    	$fwrite(fp,"1084769\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'hBFDFFFFFFFFFFFFE;
-    z = 64'hBFCFFFBFFFFF7FFF;
-    ans = 64'h3EE000001FFF8000;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h8000000000000001;
+    ReadData3E = 64'h8010000000000001;
+    ans = 64'h8010000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4095993\n");
+    	$fwrite(fp,"1085075\n");
     end
-    x = 64'hB87003FFFFFFFFFE;
-    y = 64'h402FFFFEFFEFFFFF;
-    z = 64'hC3EFFC00007FFFFF;
-    ans = 64'hC3EFFC00007FFFFF;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h7FF1C68B26BDE7D1;
+    ReadData2E = 64'hC80FBFFFFFFFF7FF;
+    ReadData3E = 64'h3E2040000000FFFF;
+    ans = 64'h7FF9C68B26BDE7D1;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4096607\n");
+    	$fwrite(fp,"1085381\n");
     end
-    x = 64'h40F0000000100200;
-    y = 64'hBFE0000000000000;
-    z = 64'hC010000000000001;
-    ans = 64'hC0E0008000100200;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hB7FF800000000FFE;
+    ReadData3E = 64'h4010000000000001;
+    ans = 64'h4010000000000001;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4097221\n");
+    	$fwrite(fp,"1085687\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'hC066FFFFFFFFFFFF;
-    z = 64'h3FDF4B5441BBD2DA;
-    ans = 64'h40571F4B5441BBD1;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'hC00FC577FE8BADBD;
+    ReadData2E = 64'h800FFFFFFFFFFFFF;
+    ReadData3E = 64'hBF10000080007FFE;
+    ans = 64'hBF10000080007FFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4097835\n");
+    	$fwrite(fp,"1085993\n");
     end
-    x = 64'h41F000001000000F;
-    y = 64'hBFEFFFFFFFFFFFFF;
-    z = 64'h2000100003FFFFFE;
-    ans = 64'hC1F000001000000E;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC7F8000000000007;
+    ReadData3E = 64'h41E1CD72352B6440;
+    ans = 64'hC7E8000000000005;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4098449\n");
+    	$fwrite(fp,"1086299\n");
     end
-    x = 64'hBFDFFFFFFFFFFFFF;
-    y = 64'h3FDF1F3616AA73E1;
-    z = 64'h3FD0000000000001;
-    ans = 64'h3F7C193D2AB1843F;
-    rn = 1;
-    rz = 0;
-    rm = 0;
-    rp = 0;
-    earlyres = 64'b0;
-    earlyressel = 0;
-    bypsel= 2'b0;
-    bypplus1 = 0;
-    byppostnorm = 0;
+    ReadData1E = 64'h4030000000000FFF;
+    ReadData2E = 64'h800FFFFFFFFFFFFE;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
 #10
     // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
     //                                     standard does not interpret the sign of a NaN."
-	wnan = &w[62:52] && |w[51:0]; 
-	xnan = &x[62:52] && |x[51:0]; 
-	ynan = &y[62:52] && |y[51:0]; 
-	znan = &z[62:52] && |z[51:0]; 
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
 	ansnan = &ans[62:52] && |ans[51:0]; 
-	xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; 
-	ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y;
-	s = ({54'b1,xnorm} + (bypsel  && bypplus1))  *  {54'b1,ynorm}; 
-	if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]}))  || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin
-		$fwrite(fp, "%h %h %h %h %h  Wrong ",x,y, z, w, ans);
-		if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero ");
-		if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm ");
-		if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm ");
-		if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm ");
-		if(invalid != 0) $fwrite(fp, "invld ");
-		if(overflow != 0) $fwrite(fp, "ovrflw ");
-		if(underflow != 0) $fwrite(fp, "unflw ");
-		if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf ");
-		if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf ");
-		if(w >  64'h7FF0000000000000 && w <  64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >  64'hFFF8000000000000 && w <  64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN ");
-		if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
-		if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN ");
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
 		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
 		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
 		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
 		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
 		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
-    	$fwrite(fp,"4099063\n");
+    	$fwrite(fp,"1086605\n");
+    end
+    ReadData1E = 64'hC03FFFF80FFFFFFF;
+    ReadData2E = 64'hFFD122B8091B2689;
+    ReadData3E = 64'h2220000000000210;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1086911\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h8010000000000000;
+    ReadData3E = 64'hC1ED21FF51F1AB58;
+    ans = 64'hC1ED21FF51F1AB58;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1087217\n");
+    end
+    ReadData1E = 64'hC34FFFFF80000007;
+    ReadData2E = 64'h3FCA54333558DA5E;
+    ReadData3E = 64'hBFD0000000000001;
+    ans = 64'hC32A5432CC080D8F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1087523\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h8010000000000001;
+    ReadData3E = 64'h000FFFFFFFFFFFFF;
+    ans = 64'h0007FFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1087829\n");
+    end
+    ReadData1E = 64'hC07DFFFF7FFFFFFF;
+    ReadData2E = 64'h40DFFF8000003FFE;
+    ReadData3E = 64'hC3E40B9AC28BB34B;
+    ans = 64'hC3E40B9AC28BD14B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1088135\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hE869B71D58044CB4;
+    ReadData3E = 64'hC00FFFFFFFFFFFFF;
+    ans = 64'hE859B71D58044CB2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1088441\n");
+    end
+    ReadData1E = 64'hC01FFFFFFEDFFFFF;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'h452192C043B9A0C1;
+    ans = 64'h452192C043B9A0C1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1088747\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h430800FFFFFFFFFF;
+    ReadData3E = 64'hBFFFFF7FFFFFFBFF;
+    ans = 64'h42F800FFFFFFFFDE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1089053\n");
+    end
+    ReadData1E = 64'h7D3FF0007FFFFFFF;
+    ReadData2E = 64'h801FFFFFFFFFFFFF;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1089359\n");
+    end
+    ReadData1E = 64'h2A4200003FFFFFFF;
+    ReadData2E = 64'hC01FFFBFFBFFFFFF;
+    ReadData3E = 64'h48B000000000BFFF;
+    ans = 64'h48B000000000BFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1089665\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h801FFFFFFFFFFFFE;
+    ReadData3E = 64'hC03FFFDFFFFFFFDE;
+    ans = 64'hC03FFFDFFFFFFFDE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1089971\n");
+    end
+    ReadData1E = 64'h88FFFFFFFF5FFFFF;
+    ReadData2E = 64'hA454024CF36DECDB;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFF;
+    ans = 64'h3CAFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1090277\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBCA0000000000000;
+    ReadData3E = 64'h7FFFFFFFFFFFFFFE;
+    ans = 64'h7FFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1090583\n");
+    end
+    ReadData1E = 64'h3F4FFFFFFBFFFFFF;
+    ReadData2E = 64'hBFCF7FFFFFFF8000;
+    ReadData3E = 64'hC01FDFFFFFFFFFFF;
+    ans = 64'hC01FE03EFFFFF81E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1090889\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC80040000007FFFE;
+    ReadData3E = 64'h3FFFFFFFFFFFFFFE;
+    ans = 64'hC7F040000007FFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1091195\n");
+    end
+    ReadData1E = 64'hBFBB61DA36F5D5A6;
+    ReadData2E = 64'hBCA0000000000001;
+    ReadData3E = 64'h3FE0007FFFFBFFFE;
+    ans = 64'h3FE0007FFFFBFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1091501\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC7EFFFFFFFE0007E;
+    ReadData3E = 64'hFFF000001FFF7FFE;
+    ans = 64'hFFF800001FFF7FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1091807\n");
+    end
+    ReadData1E = 64'hB7F893A187691B38;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFF;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1092113\n");
+    end
+    ReadData1E = 64'h37F004003FFFFFFE;
+    ReadData2E = 64'h21A00008000007FF;
+    ReadData3E = 64'hB7EFFFF800007FFE;
+    ans = 64'hB7EFFFF800007FFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1092419\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'h47E059952FFAECBD;
+    ans = 64'h47E059952FFAECBD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1092725\n");
+    end
+    ReadData1E = 64'hBFB000001003FFFE;
+    ReadData2E = 64'h41D800000007FFFF;
+    ReadData3E = 64'h801FFFFFFFFFFFFE;
+    ans = 64'hC1980000180DFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1093031\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBCAFFFFFFFFFFFFE;
+    ReadData3E = 64'hFFF0000000000000;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1093337\n");
+    end
+    ReadData1E = 64'h95BFFEFFFFFEFFFF;
+    ReadData2E = 64'h41E0000000000300;
+    ReadData3E = 64'h402FFFFFBFFFFFBE;
+    ans = 64'h402FFFFFBFFFFFBE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1093643\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC89FE00000000003;
+    ReadData3E = 64'hBFF0000000000000;
+    ans = 64'hC88FE00000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1093949\n");
+    end
+    ReadData1E = 64'h498FFFFFFFFFBFFE;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'hC1E0100000002000;
+    ans = 64'hC96FFFFFFFFFC000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1094255\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h556E8DC5F6D2D345;
+    ReadData3E = 64'hC340B053BA11A120;
+    ans = 64'h555E8DC5F6D2D343;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1094561\n");
+    end
+    ReadData1E = 64'hC3CFFFFFFFFFDFDF;
+    ReadData2E = 64'hBFD0000000000001;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'h43AF7FFFFFFFDFE1;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1094867\n");
+    end
+    ReadData1E = 64'h404EFFF7FFFFFFFE;
+    ReadData2E = 64'hFFDFFFFFEFFFFBFE;
+    ReadData3E = 64'h36201FFDFFFFFFFE;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1095173\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFF;
+    ReadData3E = 64'hBF81687F93BD4C1C;
+    ans = 64'hBFD08B43FC9DEA5F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1095479\n");
+    end
+    ReadData1E = 64'h3FEBFFFFFFFFFF80;
+    ReadData2E = 64'h380F7FFFFFDFFFFF;
+    ReadData3E = 64'h0010000000000000;
+    ans = 64'h380B8FFFFFE3FF81;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1095785\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFDFFFFFFFFFFFFE;
+    ReadData3E = 64'h7FE0000000000001;
+    ans = 64'h7FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1096091\n");
+    end
+    ReadData1E = 64'h434ACAA091937E4F;
+    ReadData2E = 64'h41E7FDFFFFFFFFFF;
+    ReadData3E = 64'h40E5EEF38E6512EB;
+    ans = 64'h4544164BC3258583;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1096397\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h001CE5742BF6BCA4;
+    ReadData3E = 64'h3FE0000000000001;
+    ans = 64'h3FE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1096703\n");
+    end
+    ReadData1E = 64'h3E800010000001FF;
+    ReadData2E = 64'hBFE0000000000000;
+    ReadData3E = 64'hBFE63277397ECFAD;
+    ans = 64'hBFE63277597EEFAD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1097009\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC03037FFFFFFFFFF;
+    ReadData3E = 64'hC27087FFFFFFFFFE;
+    ans = 64'hC2708800000081BE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1097315\n");
+    end
+    ReadData1E = 64'h401EFEFFFFFFFFFF;
+    ReadData2E = 64'hBFE0000000000001;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h4010807FFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1097621\n");
+    end
+    ReadData1E = 64'hB7E5E9AED5C5CD08;
+    ReadData2E = 64'h40100010000000FF;
+    ReadData3E = 64'h00077CD5AB42C193;
+    ans = 64'hB805E9C4BF74A42B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1097927\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h801FFFE7FFFFFFFE;
+    ans = 64'hBFDFFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1098233\n");
+    end
+    ReadData1E = 64'hBFCC7D5BA9493FB9;
+    ReadData2E = 64'h33679E2657415F04;
+    ReadData3E = 64'h8000000000000001;
+    ans = 64'hB34506E6F8CC5CED;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1098539\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFEFFFFFFFFFFFFF;
+    ReadData3E = 64'hC34FFFFFFFFFFFFF;
+    ans = 64'hC34FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1098845\n");
+    end
+    ReadData1E = 64'h3800000000000010;
+    ReadData2E = 64'hC1FFFE00001FFFFE;
+    ReadData3E = 64'hD6EFFFFFFFFFFFEB;
+    ans = 64'hD6EFFFFFFFFFFFEB;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1099151\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC66302F95CD69379;
+    ReadData3E = 64'hBFDFFFFFFFFFFFFF;
+    ans = 64'hC65302F95CD69378;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1099457\n");
+    end
+    ReadData1E = 64'hB7FFFFFFFFFFFC3E;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'hE1507FFF7FFFFFFF;
+    ans = 64'hE1507FFF7FFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1099763\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hA2FE0000000000FF;
+    ReadData3E = 64'h3801FFFFFFFFFFFF;
+    ans = 64'h3801FFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1100069\n");
+    end
+    ReadData1E = 64'hC77BC12E7CB1723C;
+    ReadData2E = 64'hBFF0000000000000;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'h477BC12E7CB1723C;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1100375\n");
+    end
+    ReadData1E = 64'hBCE000000001FC00;
+    ReadData2E = 64'h3FF80CABB0668B82;
+    ReadData3E = 64'hB9FFFFFFFCFFFFFF;
+    ans = 64'hBCE80CABB0698754;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1100681\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFF0000000000001;
+    ReadData3E = 64'h3FBFFFFFFFFFFF83;
+    ans = 64'hBFD800000000001F;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1100987\n");
+    end
+    ReadData1E = 64'hBD8184351B39575C;
+    ReadData2E = 64'hA0AFFFFBFFFFFFF8;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFF;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1101293\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h401FFFFFFFFFFFFE;
+    ans = 64'h401BFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1101599\n");
+    end
+    ReadData1E = 64'h3F9FFFDFFEFFFFFE;
+    ReadData2E = 64'hB7E00007EFFFFFFF;
+    ReadData3E = 64'hC1EFFFFFFFDFF000;
+    ans = 64'hC1EFFFFFFFDFF000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1101905\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h301FFDFFFDFFFFFE;
+    ReadData3E = 64'h3CAFFFFFFFFFFFFE;
+    ans = 64'h3CAFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1102211\n");
+    end
+    ReadData1E = 64'hC06FD8A0BAEFFBA0;
+    ReadData2E = 64'hBFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h4000020000000200;
+    ans = 64'h407FF8A4BAEFFBA2;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1102517\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h32F0007FFFFEFFFF;
+    ReadData3E = 64'hBD81FFFFFF7FFFFF;
+    ans = 64'hBD81FFFFFF7FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1102823\n");
+    end
+    ReadData1E = 64'h691FFFDFF0000000;
+    ReadData2E = 64'hC000000000000000;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'hE92FFFDFF0000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1103129\n");
+    end
+    ReadData1E = 64'h7FF000004FFFFFFE;
+    ReadData2E = 64'hC039E997F6D37059;
+    ReadData3E = 64'h331C0003FFFFFFFE;
+    ans = 64'h7FF800004FFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1103435\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'h3E9000100FFFFFFF;
+    ans = 64'hBFEFFFFF7FFF7F80;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1103741\n");
+    end
+    ReadData1E = 64'hB7E9521D61269217;
+    ReadData2E = 64'h3FCFFFFFBFFFBFFF;
+    ReadData3E = 64'h7FEFFFFFFFFFFFFE;
+    ans = 64'h7FEFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1104047\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC000000000000001;
+    ReadData3E = 64'hC010000000000000;
+    ans = 64'hC014000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1104353\n");
+    end
+    ReadData1E = 64'hCD1F485CE2E7C107;
+    ReadData2E = 64'hC00F000003FFFFFF;
+    ReadData3E = 64'hBF7407FFFFFFFFFE;
+    ans = 64'h4D3E4E19FFB98E9A;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1104659\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBF04000000007FFF;
+    ReadData3E = 64'hBCA0000000000000;
+    ans = 64'hBEF400000000FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1104965\n");
+    end
+    ReadData1E = 64'h3FC000003FFFFBFF;
+    ReadData2E = 64'hC00FFFFFFFFFFFFF;
+    ReadData3E = 64'h001000001FFFFFFE;
+    ans = 64'hBFE000003FFFFBFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1105271\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hCC0F7F226DFC3A30;
+    ReadData3E = 64'h3810800000000080;
+    ans = 64'hCBFF7F226DFC3A2E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1105577\n");
+    end
+    ReadData1E = 64'h4011FFFFFF800000;
+    ReadData2E = 64'hC00FFFFFFFFFFFFE;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hC033FFFFFF7FFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1105883\n");
+    end
+    ReadData1E = 64'h0120000000020080;
+    ReadData2E = 64'hC02FFBFFBFFFFFFF;
+    ReadData3E = 64'hBFE7FFFFFFFEFFFF;
+    ans = 64'hBFE7FFFFFFFEFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1106189\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC010000000000000;
+    ReadData3E = 64'h3FDFFC0000007FFF;
+    ans = 64'hBFF800FFFFFFDFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1106495\n");
+    end
+    ReadData1E = 64'hC7E000000401FFFF;
+    ReadData2E = 64'h3FD000000200001E;
+    ReadData3E = 64'hFFE0000000000000;
+    ans = 64'hFFE0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1106801\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC010000000000001;
+    ReadData3E = 64'h4000000000000001;
+    ans = 64'h3CC0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1107107\n");
+    end
+    ReadData1E = 64'hC07400000000000F;
+    ReadData2E = 64'hC22F7EFFFFFFFFFF;
+    ReadData3E = 64'h402E0FDFBF9D095F;
+    ans = 64'h42B3AF6000000F16;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1107413\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h41C0020000040000;
+    ReadData3E = 64'h0010000000000001;
+    ans = 64'h41B002000003FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1107719\n");
+    end
+    ReadData1E = 64'hAD8FFFFFFFF80007;
+    ReadData2E = 64'hC01FFFFFFFFFFFFF;
+    ReadData3E = 64'h42960AE5D04FDC6B;
+    ans = 64'h42960AE5D04FDC6B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1108025\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC0251BE94A80FD14;
+    ReadData3E = 64'hBFEFFFFFFFDFFFC0;
+    ans = 64'hC0191BE94A7CFD0B;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1108331\n");
+    end
+    ReadData1E = 64'hBE700000081FFFFE;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'h3FF0000080000040;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1108637\n");
+    end
+    ReadData1E = 64'h001FFE0000001FFF;
+    ReadData2E = 64'h3F40B59FC2D8D6D9;
+    ReadData3E = 64'hD4800001FFFFFFFE;
+    ans = 64'hD4800001FFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1108943\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC01FFFFFFFFFFFFE;
+    ReadData3E = 64'h43EFFC000000FFFF;
+    ans = 64'h43EFFC000000FFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1109249\n");
+    end
+    ReadData1E = 64'h3F50004000001FFF;
+    ReadData2E = 64'h4040000003FBFFFF;
+    ReadData3E = 64'h4340000000000001;
+    ans = 64'h4340000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1109555\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC340000000000000;
+    ReadData3E = 64'hBFFFFFFFFFFFFFFF;
+    ans = 64'hC330000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1109861\n");
+    end
+    ReadData1E = 64'hC9A000000FFFFFC0;
+    ReadData2E = 64'h401FC0000000001F;
+    ReadData3E = 64'h41E62D1014622F6F;
+    ans = 64'hC9CFC0001FBFFFA0;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1110167\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC08000000004003F;
+    ReadData3E = 64'h800FFFFFFFFFFFFF;
+    ans = 64'hC07000000004003E;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1110473\n");
+    end
+    ReadData1E = 64'hC7E00020000007FF;
+    ReadData2E = 64'hC340000000000001;
+    ReadData3E = 64'h3D8081FFFFFFFFFF;
+    ans = 64'h4B30002000000800;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1110779\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3096C2873C3B7AB7;
+    ReadData3E = 64'h3CCFFFFDFFFFBFFF;
+    ans = 64'h3CCFFFFDFFFFBFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1111085\n");
+    end
+    ReadData1E = 64'h403FFFFEFFFFFFFB;
+    ReadData2E = 64'hC34FFFFFFFFFFFFF;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hC39FFFFEFFFFFFFA;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1111391\n");
+    end
+    ReadData1E = 64'hC1F2000FFFFFFFFF;
+    ReadData2E = 64'h4F3003FFFFFEFFFE;
+    ReadData3E = 64'h4BDFFFFFFF8001FE;
+    ans = 64'hD132049003FEDFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1111697\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hC34FFFFFFFFFFFFE;
+    ReadData3E = 64'hB8101000003FFFFF;
+    ans = 64'hC33FFFFFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1112003\n");
+    end
+    ReadData1E = 64'h3FF719E56C2EBF0F;
+    ReadData2E = 64'hB802BAD5445737FA;
+    ReadData3E = 64'hC01FFFFFFFFFFFFF;
+    ans = 64'hC01FFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1112309\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hFFE0000000000000;
+    ReadData3E = 64'h3FEFFFFFFFFFFFFE;
+    ans = 64'hFFCFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1112615\n");
+    end
+    ReadData1E = 64'h37FF9FFFFFFFFFFF;
+    ReadData2E = 64'hC85FFFFFFFFFF07E;
+    ReadData3E = 64'h40010000000FFFFF;
+    ans = 64'hC06F5BFFFFFFB0AC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1112921\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hBFFFFFF8000003FE;
+    ReadData3E = 64'hFFFFFFFFFFFFFFFE;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1113227\n");
+    end
+    ReadData1E = 64'hBFCEFFFFFFFFEFFF;
+    ReadData2E = 64'hFFE0000000000001;
+    ReadData3E = 64'hC030000000001200;
+    ans = 64'h7FBEFFFFFFFFF001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1113533\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hFFDFFFDFFFFFFFFE;
+    ReadData3E = 64'hBFD0100007FFFFFF;
+    ans = 64'hFFCFFFDFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1113839\n");
+    end
+    ReadData1E = 64'h401000000007FBFE;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1114145\n");
+    end
+    ReadData1E = 64'hC1CAE55EE9B7731D;
+    ReadData2E = 64'hC1DBFFFFFFFFFFFE;
+    ReadData3E = 64'hC1E05FFFFFFFFFFE;
+    ans = 64'h43B788B30BFD84B8;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1114451\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFF;
+    ReadData3E = 64'h34FFFFFEFFFF0000;
+    ans = 64'hFFDFFFFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1114757\n");
+    end
+    ReadData1E = 64'h3FBFFBFFFFFFFFFE;
+    ReadData2E = 64'hFFEFFFFBFFBFFFFF;
+    ReadData3E = 64'h400FFFFFFFFFFFFE;
+    ans = 64'hFFBFFBFC004007FD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1115063\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hFFEFFFFFFFFFFFFE;
+    ReadData3E = 64'hBFE0000000000000;
+    ans = 64'hFFDFFFFFFFFFFFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1115369\n");
+    end
+    ReadData1E = 64'h002007FFFFFBFFFF;
+    ReadData2E = 64'hBFC926A50C7B04BB;
+    ReadData3E = 64'h3DCFFFFFFFFFFFFE;
+    ans = 64'h3DCFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1115675\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hB707FFFFFFEFFFFF;
+    ReadData3E = 64'h7FF0000000000000;
+    ans = 64'h7FF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1115981\n");
+    end
+    ReadData1E = 64'h381000007F000000;
+    ReadData2E = 64'hFFF0000000000000;
+    ReadData3E = 64'h7FDFFFFF00000020;
+    ans = 64'hFFF0000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1116287\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3CAFFDFFFFFFFF00;
+    ReadData3E = 64'h39CFDFFFFDFFFFFE;
+    ans = 64'h3C9FFDFFFFFFFFFD;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1116593\n");
+    end
+    ReadData1E = 64'h3FFFFFFFFFFFF7EE;
+    ReadData2E = 64'hFFF0000000000001;
+    ReadData3E = 64'hBCAFFFFFFFFFFFFF;
+    ans = 64'hFFF8000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1116899\n");
+    end
+    ReadData1E = 64'h41503FFFFFFFEFFE;
+    ReadData2E = 64'hB67FFFF7FDFFFFFF;
+    ReadData3E = 64'hBFD7FFFFFFFEFFFF;
+    ans = 64'hBFD7FFFFFFFEFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1117205\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFF;
+    ReadData3E = 64'h366FFE0000000007;
+    ans = 64'hFFFFFFFFFFFFFFFF;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1117511\n");
+    end
+    ReadData1E = 64'hB7F0001FFFDFFFFF;
+    ReadData2E = 64'hBF5FFFFFF07FFFFF;
+    ReadData3E = 64'hC000000000000000;
+    ans = 64'hC000000000000000;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1117817\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'hFFFFFFFFFFFFFFFE;
+    ReadData3E = 64'h3FD0000000000001;
+    ans = 64'hFFFFFFFFFFFFFFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1118123\n");
+    end
+    ReadData1E = 64'h47E0000000003EFE;
+    ReadData2E = 64'hB72000013FFFFFFF;
+    ReadData3E = 64'h403FFFFEFFFFF7FE;
+    ans = 64'h403FFFFAFFFFA7FE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1118429\n");
+    end
+    ReadData1E = 64'h3FDFFFFFFFFFFFFE;
+    ReadData2E = 64'h3F0FFFFFFFF7FFC0;
+    ReadData3E = 64'hFFE0000000000001;
+    ans = 64'hFFE0000000000001;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1118735\n");
+    end
+    ReadData1E = 64'h9280000001FFFFFE;
+    ReadData2E = 64'h0000000000000000;
+    ReadData3E = 64'hBF5008000001FFFE;
+    ans = 64'hBF5008000001FFFE;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1119041\n");
+    end
+    ReadData1E = 64'h3FE0000000000000;
+    ReadData2E = 64'h41E0000000003F80;
+    ReadData3E = 64'h3FFFBFFFFFFFF000;
+    ans = 64'h41D00000007F3F80;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1119347\n");
+    end
+    ReadData1E = 64'hC3F000200003FFFE;
+    ReadData2E = 64'h0000000000000001;
+    ReadData3E = 64'h001FFFFFFFFFFFFE;
+    ans = 64'h80CFFC400007FFFC;
+    FrmE = 3'b000;
+#10
+    // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this
+    //                                     standard does not interpret the sign of a NaN."
+	wnan = &FmaResultM[62:52] && |FmaResultM[51:0]; 
+	xnan = &ReadData1E[62:52] && |ReadData1E[51:0]; 
+	ynan = &ReadData2E[62:52] && |ReadData2E[51:0]; 
+	znan = &ReadData3E[62:52] && |ReadData3E[51:0]; 
+	ansnan = &ans[62:52] && |ans[51:0]; 
+	xnorm = ~(|ReadData1E[62:52]) && |ReadData1E[51:0] ? {ReadData1E[50:0], 1'b0} : ReadData1E; 
+	ynorm = ~(|ReadData2E[62:52]) && |ReadData2E[51:0] ? {ReadData2E[50:0], 1'b0} : ReadData2E;
+	if((!wnan && (FmaResultM != ans)) || (wnan && ansnan && ~(((xnan && (FmaResultM[62:0] == {ReadData1E[62:52],1'b1,ReadData1E[50:0]})) || (ynan && (FmaResultM[62:0] == {ReadData2E[62:52],1'b1,ReadData2E[50:0]}))  || (znan && (FmaResultM[62:0] == {ReadData3E[62:52],1'b1,ReadData3E[50:0]})) || (FmaResultM[62:0] == ans[62:0])) ))) begin
+		$fwrite(fp, "%h %h %h %h %h  Wrong ",ReadData1E,ReadData2E, ReadData3E, FmaResultM, ans);
+		$fwrite(fp, "FmaResultM=%d ",$signed(aligncnt));
+		if(FmaResultM == 64'h8000000000000000) $fwrite(fp, "FmaResultM=-zero ");
+		if(~(|ReadData1E[62:52]) && |ReadData1E[51:0]) $fwrite(fp, "xdenorm ");
+		if(~(|ReadData2E[62:52]) && |ReadData2E[51:0]) $fwrite(fp, "ydenorm ");
+		if(~(|ReadData3E[62:52]) && |ReadData3E[51:0]) $fwrite(fp, "zdenorm ");
+		if(FmaFlagsM[4] != 0) $fwrite(fp, "invld ");
+		if(FmaFlagsM[2] != 0) $fwrite(fp, "ovrflw ");
+		if(FmaFlagsM[1] != 0) $fwrite(fp, "unflw ");
+		if(FmaResultM == 64'hFFF0000000000000) $fwrite(fp, "FmaResultM=-inf ");
+		if(FmaResultM == 64'h7FF0000000000000) $fwrite(fp, "FmaResultM=+inf ");
+		if(FmaResultM >  64'h7FF0000000000000 && FmaResultM <  64'h7FF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >  64'hFFF8000000000000 && FmaResultM <  64'hFFF8000000000000 ) $fwrite(fp, "FmaResultM=sigNaN ");
+		if(FmaResultM >= 64'h7FF8000000000000 && FmaResultM <= 64'h7FFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(FmaResultM >= 64'hFFF8000000000000 && FmaResultM <= 64'hFFFfffffffffffff ) $fwrite(fp, "FmaResultM=qutNaN ");
+		if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf ");
+		if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf ");
+		if(ans >  64'h7FF0000000000000 && ans <  64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >  64'hFFF8000000000000 && ans <  64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN ");
+		if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+		if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN ");
+    	$fwrite(fp,"1119653\n");
     end
 	$stop;
 	end
diff --git a/wally-pipelined/src/fpu/FMA/tbgen/tbhead.v b/wally-pipelined/src/fpu/FMA/tbgen/tbhead.v
index c5613cc45..8e8a64709 100644
--- a/wally-pipelined/src/fpu/FMA/tbgen/tbhead.v
+++ b/wally-pipelined/src/fpu/FMA/tbgen/tbhead.v
@@ -2,38 +2,27 @@
 module tb;
 
 
- reg 		[63:0]		x;
- reg 		[63:0]		y;
- reg 		[63:0]		z;
- reg 		[63:0]		ans;
- reg 						rn;
- reg 						rz;
- reg 						rm;
- reg 						rp;
- reg 		[63:0]		earlyres;
- reg 						earlyressel;
- reg 		[1:0]			bypsel;
- reg 						bypplus1;
- reg 						byppostnorm;
- wire 	[63:0]		w;
- wire 	[63:0]		wbypass;
- wire 		 			invalid;
- wire 					overflow;
- wire 					underflow;
- wire 					inexact;
+ reg 	[63:0]		ReadData1E;
+ reg 	[63:0]		ReadData2E;
+ reg 	[63:0]		ReadData3E;
+ reg 	[63:0]		ans;
+ reg 	[2:0]		FrmE;
+ wire 	[63:0]		FmaResultM;
+ wire 	[4:0]	 	FmaFlagsM;
 
 integer fp;
 reg wnan;
 reg xnan;
 reg ynan;
 reg znan;
+wire [12:0] aligncnt;
 reg ansnan;
 reg		[105:0]		s;				//	partial product 2	
 reg		[51:0] 		xnorm;
 reg 		[51:0] 		ynorm;
 
 localparam period = 20;  
-fmac UUT(.*);
+fma UUT(.*);
 
 
 initial 
diff --git a/wally-pipelined/src/fpu/FMA/tbgen/test_gen.sh b/wally-pipelined/src/fpu/FMA/tbgen/test_gen.sh
index 0a4918470..fc79a9848 100755
--- a/wally-pipelined/src/fpu/FMA/tbgen/test_gen.sh
+++ b/wally-pipelined/src/fpu/FMA/tbgen/test_gen.sh
@@ -1 +1 @@
-testfloat_gen f64_mulAdd -n 6133248 -rnear_even -seed 113355 -level 1 >> testFloat
\ No newline at end of file
+testfloat_gen f64_mulAdd -n 6133248 -rminMag -seed 113355 -level 1 >> testFloat
diff --git a/wally-pipelined/src/fpu/csa.sv b/wally-pipelined/src/fpu/csa.sv
index af5decb02..1e5682cfc 100644
--- a/wally-pipelined/src/fpu/csa.sv
+++ b/wally-pipelined/src/fpu/csa.sv
@@ -50,7 +50,7 @@ module FA_array (S, C, A, B, Ci) ;
    genvar 	  i;
    generate
       for (i = 0; i < n; i = i + 1) begin : index
-	 fa FA1(.S(S[i]), .C(C[i]), .A(A[i]), .B(B[i]), .Ci(Ci[i]));
+	 fa FA1(.sum(S[i]), .carry(C[i]), .a(A[i]), .b(B[i]), .c(Ci[i]));
       end
    endgenerate